Docs.

Bumps [actions/setup-go](https://github.com/actions/setup-go) from 5 to 6.
- [Release notes](https://github.com/actions/setup-go/releases)
- [Commits](https://github.com/actions/setup-go/compare/v5...v6)

---
updated-dependencies:
- dependency-name: actions/setup-go
  dependency-version: '6'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/workflows/libc.yml

@@ -15,7 +15,7 @@ jobs:
 
     steps:
     - uses: actions/checkout@v5
-    - uses: actions/setup-go@v5
+    - uses: actions/setup-go@v6
       with: { go-version: stable }
 
     - name: Benchmark

.github/workflows/repro.yml

@@ -23,7 +23,7 @@ jobs:
       shell: bash
       run: .github/workflows/repro.sh
 
-    - uses: actions/attest-build-provenance@v2
+    - uses: actions/attest-build-provenance@v3
       if: matrix.os == 'ubuntu-latest'
       with:
         subject-path: |

.github/workflows/test.yml

@@ -31,7 +31,7 @@ jobs:
 
     steps:
     - uses: actions/checkout@v5
-    - uses: actions/setup-go@v5
+    - uses: actions/setup-go@v6
       with: { go-version: stable }
 
     - name: Format
@@ -175,7 +175,7 @@ jobs:
     steps:
     - uses: bytecodealliance/actions/wasmtime/setup@v1
     - uses: actions/checkout@v5
-    - uses: actions/setup-go@v5
+    - uses: actions/setup-go@v6
       with: { go-version: stable }
 
     - name: Set path
@@ -196,7 +196,7 @@ jobs:
     steps:
     - uses: docker/setup-qemu-action@v3
     - uses: actions/checkout@v5
-    - uses: actions/setup-go@v5
+    - uses: actions/setup-go@v6
       with: { go-version: stable }
 
     - name: Test 386 (32-bit)
@@ -217,7 +217,7 @@ jobs:
 
     steps:
     - uses: actions/checkout@v5
-    - uses: actions/setup-go@v5
+    - uses: actions/setup-go@v6
       with: { go-version: stable }
 
     - name: Test
@@ -229,7 +229,7 @@ jobs:
 
     steps:
     - uses: actions/checkout@v5
-    - uses: actions/setup-go@v5
+    - uses: actions/setup-go@v6
       with: { go-version: stable }
 
     - name: Test

conn.go

@@ -444,20 +444,27 @@ func (c *Conn) Status(op DBStatus, reset bool) (current, highwater int, err erro
 // https://sqlite.org/c3ref/table_column_metadata.html
 func (c *Conn) TableColumnMetadata(schema, table, column string) (declType, collSeq string, notNull, primaryKey, autoInc bool, err error) {
 	defer c.arena.mark()()
-
-	var schemaPtr, columnPtr ptr_t
-	declTypePtr := c.arena.new(ptrlen)
-	collSeqPtr := c.arena.new(ptrlen)
-	notNullPtr := c.arena.new(ptrlen)
-	autoIncPtr := c.arena.new(ptrlen)
-	primaryKeyPtr := c.arena.new(ptrlen)
+	var (
+		declTypePtr   ptr_t
+		collSeqPtr    ptr_t
+		notNullPtr    ptr_t
+		primaryKeyPtr ptr_t
+		autoIncPtr    ptr_t
+		columnPtr     ptr_t
+		schemaPtr     ptr_t
+	)
+	if column != "" {
+		declTypePtr = c.arena.new(ptrlen)
+		collSeqPtr = c.arena.new(ptrlen)
+		notNullPtr = c.arena.new(ptrlen)
+		primaryKeyPtr = c.arena.new(ptrlen)
+		autoIncPtr = c.arena.new(ptrlen)
+		columnPtr = c.arena.string(column)
+	}
 	if schema != "" {
 		schemaPtr = c.arena.string(schema)
 	}
 	tablePtr := c.arena.string(table)
-	if column != "" {
-		columnPtr = c.arena.string(column)
-	}
 
 	rc := res_t(c.call("sqlite3_table_column_metadata", stk_t(c.handle),
 		stk_t(schemaPtr), stk_t(tablePtr), stk_t(columnPtr),

context.go

@@ -1,7 +1,6 @@
 package sqlite3
 
 import (
-	"encoding/json"
 	"errors"
 	"math"
 	"time"
@@ -173,21 +172,6 @@ func (ctx Context) ResultPointer(ptr any) {
 		stk_t(ctx.handle), stk_t(valPtr))
 }
 
-// ResultJSON sets the result of the function to the JSON encoding of value.
-//
-// https://sqlite.org/c3ref/result_blob.html
-func (ctx Context) ResultJSON(value any) {
-	err := json.NewEncoder(callbackWriter(func(p []byte) (int, error) {
-		ctx.ResultRawText(p[:len(p)-1]) // remove the newline
-		return 0, nil
-	})).Encode(value)
-
-	if err != nil {
-		ctx.ResultError(err)
-		return // notest
-	}
-}
-
 // ResultValue sets the result of the function to a copy of [Value].
 //
 // https://sqlite.org/c3ref/result_blob.html

driver/driver.go

@@ -607,14 +607,24 @@ func (r resultRowsAffected) RowsAffected() (int64, error) {
 type scantype byte
 
 const (
-	_ANY  scantype = iota
-	_INT  scantype = scantype(sqlite3.INTEGER)
-	_REAL scantype = scantype(sqlite3.FLOAT)
-	_TEXT scantype = scantype(sqlite3.TEXT)
-	_BLOB scantype = scantype(sqlite3.BLOB)
-	_NULL scantype = scantype(sqlite3.NULL)
-	_BOOL scantype = iota
+	_ANY scantype = iota
+	_INT
+	_REAL
+	_TEXT
+	_BLOB
+	_NULL
+	_BOOL
 	_TIME
+	_NOT_NULL
+)
+
+var (
+	_ [0]struct{} = [scantype(sqlite3.INTEGER) - _INT]struct{}{}
+	_ [0]struct{} = [scantype(sqlite3.FLOAT) - _REAL]struct{}{}
+	_ [0]struct{} = [scantype(sqlite3.TEXT) - _TEXT]struct{}{}
+	_ [0]struct{} = [scantype(sqlite3.BLOB) - _BLOB]struct{}{}
+	_ [0]struct{} = [scantype(sqlite3.NULL) - _NULL]struct{}{}
+	_ [0]struct{} = [_NOT_NULL & (_NOT_NULL - 1)]struct{}{}
 )
 
 func scanFromDecl(decl string) scantype {
@@ -644,8 +654,8 @@ type rows struct {
 	*stmt
 	names []string
 	types []string
-	nulls []bool
 	scans []scantype
+	dest  []driver.Value
 }
 
 var (
@@ -675,34 +685,36 @@ func (r *rows) Columns() []string {
 
 func (r *rows) scanType(index int) scantype {
 	if r.scans == nil {
-		count := r.Stmt.ColumnCount()
+		count := len(r.names)
 		scans := make([]scantype, count)
 		for i := range scans {
 			scans[i] = scanFromDecl(strings.ToUpper(r.Stmt.ColumnDeclType(i)))
 		}
 		r.scans = scans
 	}
-	return r.scans[index]
+	return r.scans[index] &^ _NOT_NULL
 }
 
 func (r *rows) loadColumnMetadata() {
-	if r.nulls == nil {
+	if r.types == nil {
 		c := r.Stmt.Conn()
-		count := r.Stmt.ColumnCount()
-		nulls := make([]bool, count)
+		count := len(r.names)
 		types := make([]string, count)
 		scans := make([]scantype, count)
-		for i := range nulls {
+		for i := range types {
+			var notnull bool
 			if col := r.Stmt.ColumnOriginName(i); col != "" {
-				types[i], _, nulls[i], _, _, _ = c.TableColumnMetadata(
+				types[i], _, notnull, _, _, _ = c.TableColumnMetadata(
 					r.Stmt.ColumnDatabaseName(i),
 					r.Stmt.ColumnTableName(i),
 					col)
 				types[i] = strings.ToUpper(types[i])
 				scans[i] = scanFromDecl(types[i])
+				if notnull {
+					scans[i] |= _NOT_NULL
+				}
 			}
 		}
-		r.nulls = nulls
 		r.types = types
 		r.scans = scans
 	}
@@ -721,15 +733,13 @@ func (r *rows) ColumnTypeDatabaseTypeName(index int) string {
 
 func (r *rows) ColumnTypeNullable(index int) (nullable, ok bool) {
 	r.loadColumnMetadata()
-	if r.nulls[index] {
-		return false, true
-	}
-	return true, false
+	nullable = r.scans[index]&^_NOT_NULL == 0
+	return nullable, !nullable
 }
 
 func (r *rows) ColumnTypeScanType(index int) (typ reflect.Type) {
 	r.loadColumnMetadata()
-	scan := r.scans[index]
+	scan := r.scans[index] &^ _NOT_NULL
 
 	if r.Stmt.Busy() {
 		// SQLite is dynamically typed and we now have a row.
@@ -772,6 +782,7 @@ func (r *rows) ColumnTypeScanType(index int) (typ reflect.Type) {
 }
 
 func (r *rows) Next(dest []driver.Value) error {
+	r.dest = nil
 	c := r.Stmt.Conn()
 	if old := c.SetInterrupt(r.ctx); old != r.ctx {
 		defer c.SetInterrupt(old)
@@ -790,18 +801,7 @@ func (r *rows) Next(dest []driver.Value) error {
 	}
 	for i := range dest {
 		scan := r.scanType(i)
-		switch v := dest[i].(type) {
-		case int64:
-			if scan == _BOOL {
-				switch v {
-				case 1:
-					dest[i] = true
-				case 0:
-					dest[i] = false
-				}
-				continue
-			}
-		case []byte:
+		if v, ok := dest[i].([]byte); ok {
 			if len(v) == cap(v) { // a BLOB
 				continue
 			}
@@ -816,38 +816,49 @@ func (r *rows) Next(dest []driver.Value) error {
 				}
 			}
 			dest[i] = string(v)
-		case float64:
-			break
-		default:
-			continue
 		}
-		if scan == _TIME {
+		switch scan {
+		case _TIME:
 			t, err := r.tmRead.Decode(dest[i])
 			if err == nil {
 				dest[i] = t
-				continue
+			}
+		case _BOOL:
+			switch dest[i] {
+			case int64(0):
+				dest[i] = false
+			case int64(1):
+				dest[i] = true
 			}
 		}
 	}
+	r.dest = dest
 	return nil
 }
 
-func (r *rows) ScanColumn(dest any, index int) error {
+func (r *rows) ScanColumn(dest any, index int) (err error) {
 	// notest // Go 1.26
-	var ptr *time.Time
+	var tm *time.Time
+	var ok *bool
 	switch d := dest.(type) {
 	case *time.Time:
-		ptr = d
+		tm = d
 	case *sql.NullTime:
-		ptr = &d.Time
+		tm = &d.Time
+		ok = &d.Valid
 	case *sql.Null[time.Time]:
-		ptr = &d.V
+		tm = &d.V
+		ok = &d.Valid
 	default:
 		return driver.ErrSkip
 	}
-	if t := r.Stmt.ColumnTime(index, r.tmRead); !t.IsZero() {
-		*ptr = t
-		return nil
+	value := r.dest[index]
+	*tm, err = r.tmRead.Decode(value)
+	if ok != nil {
+		*ok = err == nil
+		if value == nil {
+			return nil
+		}
 	}
-	return driver.ErrSkip
+	return err
 }

driver/driver_test.go

@@ -8,6 +8,7 @@ import (
 	"math"
 	"net/url"
 	"reflect"
+	"strings"
 	"testing"
 	"time"
 
@@ -33,7 +34,7 @@ func Test_Open_error(t *testing.T) {
 func Test_Open_dir(t *testing.T) {
 	t.Parallel()
 
-	db, err := sql.Open("sqlite3", ".")
+	db, err := Open(".")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -50,11 +51,11 @@ func Test_Open_dir(t *testing.T) {
 
 func Test_Open_pragma(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t, url.Values{
+	dsn := memdb.TestDB(t, url.Values{
 		"_pragma": {"busy_timeout(1000)"},
 	})
 
-	db, err := sql.Open("sqlite3", tmp)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -72,11 +73,11 @@ func Test_Open_pragma(t *testing.T) {
 
 func Test_Open_pragma_invalid(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t, url.Values{
+	dsn := memdb.TestDB(t, url.Values{
 		"_pragma": {"busy_timeout 1000"},
 	})
 
-	db, err := sql.Open("sqlite3", tmp)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -100,12 +101,12 @@ func Test_Open_pragma_invalid(t *testing.T) {
 
 func Test_Open_txLock(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t, url.Values{
+	dsn := memdb.TestDB(t, url.Values{
 		"_txlock": {"exclusive"},
 		"_pragma": {"busy_timeout(1000)"},
 	})
 
-	db, err := sql.Open("sqlite3", tmp)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -136,11 +137,11 @@ func Test_Open_txLock(t *testing.T) {
 
 func Test_Open_txLock_invalid(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t, url.Values{
+	dsn := memdb.TestDB(t, url.Values{
 		"_txlock": {"xclusive"},
 	})
 
-	_, err := sql.Open("sqlite3", tmp+"_txlock=xclusive")
+	_, err := Open(dsn)
 	if err == nil {
 		t.Fatal("want error")
 	}
@@ -151,31 +152,28 @@ func Test_Open_txLock_invalid(t *testing.T) {
 
 func Test_BeginTx(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t, url.Values{
+	dsn := memdb.TestDB(t, url.Values{
 		"_txlock": {"exclusive"},
 		"_pragma": {"busy_timeout(0)"},
 	})
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	db, err := sql.Open("sqlite3", tmp)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db.Close()
 
-	_, err = db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted})
+	_, err = db.BeginTx(t.Context(), &sql.TxOptions{Isolation: sql.LevelReadCommitted})
 	if err.Error() != string(util.IsolationErr) {
 		t.Error("want isolationErr")
 	}
 
-	tx1, err := db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
+	tx1, err := db.BeginTx(t.Context(), &sql.TxOptions{ReadOnly: true})
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	tx2, err := db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
+	tx2, err := db.BeginTx(t.Context(), &sql.TxOptions{ReadOnly: true})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -201,9 +199,9 @@ func Test_BeginTx(t *testing.T) {
 
 func Test_nested_context(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := sql.Open("sqlite3", tmp)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -236,7 +234,7 @@ func Test_nested_context(t *testing.T) {
 
 	want(outer, 0)
 
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx, cancel := context.WithCancel(t.Context())
 	defer cancel()
 
 	inner, err := tx.QueryContext(ctx, `SELECT value FROM generate_series(0)`)
@@ -259,9 +257,9 @@ func Test_nested_context(t *testing.T) {
 
 func Test_Prepare(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := sql.Open("sqlite3", tmp)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -300,24 +298,21 @@ func Test_Prepare(t *testing.T) {
 
 func Test_QueryRow_named(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	db, err := sql.Open("sqlite3", tmp)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db.Close()
 
-	conn, err := db.Conn(ctx)
+	conn, err := db.Conn(t.Context())
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer conn.Close()
 
-	stmt, err := conn.PrepareContext(ctx, `SELECT ?, ?5, :AAA, @AAA, $AAA`)
+	stmt, err := conn.PrepareContext(t.Context(), `SELECT ?, ?5, :AAA, @AAA, $AAA`)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -353,9 +348,9 @@ func Test_QueryRow_named(t *testing.T) {
 
 func Test_QueryRow_blob_null(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := sql.Open("sqlite3", tmp)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -390,11 +385,11 @@ func Test_time(t *testing.T) {
 
 	for _, fmt := range []string{"auto", "sqlite", "rfc3339", time.ANSIC} {
 		t.Run(fmt, func(t *testing.T) {
-			tmp := memdb.TestDB(t, url.Values{
+			dsn := memdb.TestDB(t, url.Values{
 				"_timefmt": {fmt},
 			})
 
-			db, err := sql.Open("sqlite3", tmp)
+			db, err := Open(dsn)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -437,9 +432,9 @@ func Test_ColumnType_ScanType(t *testing.T) {
 	)
 
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := sql.Open("sqlite3", tmp)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -526,6 +521,39 @@ func Test_ColumnType_ScanType(t *testing.T) {
 	}
 }
 
+func Test_rows_ScanColumn(t *testing.T) {
+	t.Parallel()
+	dsn := memdb.TestDB(t)
+
+	db, err := Open(dsn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	var tm time.Time
+	err = db.QueryRow(`SELECT NULL`).Scan(&tm)
+	if err == nil {
+		t.Error("want error")
+	}
+	// Go 1.26
+	err = db.QueryRow(`SELECT datetime()`).Scan(&tm)
+	if err != nil && !strings.HasPrefix(err.Error(), "sql: Scan error") {
+		t.Error(err)
+	}
+
+	var nt sql.NullTime
+	err = db.QueryRow(`SELECT NULL`).Scan(&nt)
+	if err != nil {
+		t.Error(err)
+	}
+	// Go 1.26
+	err = db.QueryRow(`SELECT datetime()`).Scan(&nt)
+	if err != nil && !strings.HasPrefix(err.Error(), "sql: Scan error") {
+		t.Error(err)
+	}
+}
+
 func Benchmark_loop(b *testing.B) {
 	db, err := Open(":memory:")
 	if err != nil {
@@ -539,12 +567,8 @@ func Benchmark_loop(b *testing.B) {
 		b.Fatal(err)
 	}
 
-	ctx, cancel := context.WithCancel(context.Background())
-	b.Cleanup(cancel)
-
-	b.ResetTimer()
-	for range b.N {
-		_, err := db.ExecContext(ctx,
+	for b.Loop() {
+		_, err := db.ExecContext(b.Context(),
 			`WITH RECURSIVE c(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM c WHERE x < 1000000) SELECT x FROM c;`)
 		if err != nil {
 			b.Fatal(err)

driver/util_test.go

@@ -1,7 +1,6 @@
 package driver
 
 import (
-	"context"
 	"database/sql/driver"
 	"slices"
 	"testing"
@@ -56,7 +55,7 @@ func Fuzz_notWhitespace(f *testing.F) {
 			t.SkipNow()
 		}
 
-		c, err := db.Conn(context.Background())
+		c, err := db.Conn(t.Context())
 		if err != nil {
 			t.Fatal(err)
 		}

embed/bcw2/build.sh

@@ -62,8 +62,9 @@ cd ~-
 	$(awk '{print "-Wl,--export="$0}' ../exports.txt)
 
 "$BINARYEN/wasm-ctor-eval" -g -c _initialize bcw2.wasm -o bcw2.tmp
-"$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
-	bcw2.tmp -o bcw2.wasm --low-memory-unused \
+"$BINARYEN/wasm-opt" -g bcw2.tmp -o bcw2.wasm \
+	--low-memory-unused --gufa --generate-global-effects --converge -O3 \
 	--enable-mutable-globals --enable-nontrapping-float-to-int \
 	--enable-simd --enable-bulk-memory --enable-sign-ext \
-	--enable-reference-types --enable-multivalue
+	--enable-reference-types --enable-multivalue \
+	--strip --strip-producers

embed/bcw2/go.mod

@@ -1,14 +1,12 @@
 module github.com/ncruces/go-sqlite3/embed/bcw2
 
-go 1.23.0
+go 1.24.0
 
-toolchain go1.24.0
-
-require github.com/ncruces/go-sqlite3 v0.27.1
+require github.com/ncruces/go-sqlite3 v0.29.0
 
 require (
 	github.com/ncruces/julianday v1.0.0 // indirect
 	github.com/ncruces/sort v0.1.5 // indirect
 	github.com/tetratelabs/wazero v1.9.0 // indirect
-	golang.org/x/sys v0.35.0 // indirect
+	golang.org/x/sys v0.36.0 // indirect
 )

embed/bcw2/go.sum

@@ -1,12 +1,12 @@
-github.com/ncruces/go-sqlite3 v0.27.1 h1:suqlM7xhSyDVMV9RgX99MCPqt9mB6YOCzHZuiI36K34=
-github.com/ncruces/go-sqlite3 v0.27.1/go.mod h1:gpF5s+92aw2MbDmZK0ZOnCdFlpe11BH20CTspVqri0c=
+github.com/ncruces/go-sqlite3 v0.29.0 h1:1tsLiagCoqZEfcHDeKsNSv5jvrY/Iu393pAnw2wLNJU=
+github.com/ncruces/go-sqlite3 v0.29.0/go.mod h1:r1hSvYKPNJ+OlUA1O3r8o9LAawzPAlqeZiIdxTBBBJ0=
 github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M=
 github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
 github.com/ncruces/sort v0.1.5 h1:fiFWXXAqKI8QckPf/6hu/bGFwcEPrirIOFaJqWujs4k=
 github.com/ncruces/sort v0.1.5/go.mod h1:obJToO4rYr6VWP0Uw5FYymgYGt3Br4RXcs/JdKaXAPk=
 github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
 github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
-golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
-golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.27.0 h1:4fGWRpyh641NLlecmyl4LOe6yDdfaYNrGb2zdfo4JV4=
-golang.org/x/text v0.27.0/go.mod h1:1D28KMCvyooCX9hBiosv5Tz/+YLxj0j7XhWjpSUF7CU=
+golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
+golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk=
+golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=

embed/build.sh

@@ -27,8 +27,9 @@ trap 'rm -f sqlite3.tmp' EXIT
 	$(awk '{print "-Wl,--export="$0}' exports.txt)
 
 "$BINARYEN/wasm-ctor-eval" -g -c _initialize sqlite3.wasm -o sqlite3.tmp
-"$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
-	sqlite3.tmp -o sqlite3.wasm --low-memory-unused \
+"$BINARYEN/wasm-opt" -g sqlite3.tmp -o sqlite3.wasm \
+	--low-memory-unused --gufa --generate-global-effects --converge -O3 \
 	--enable-mutable-globals --enable-nontrapping-float-to-int \
 	--enable-simd --enable-bulk-memory --enable-sign-ext \
-	--enable-reference-types --enable-multivalue
+	--enable-reference-types --enable-multivalue \
+	--strip --strip-producers

ext/array/array_test.go

@@ -88,9 +88,9 @@ func Example() {
 
 func Test_cursor_Column(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, array.Register)
+	db, err := driver.Open(dsn, array.Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/fileio/fileio_test.go

@@ -17,9 +17,9 @@ import (
 
 func Test_lsmode(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, fileio.Register)
+	db, err := driver.Open(dsn, fileio.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -53,9 +53,9 @@ func Test_readfile(t *testing.T) {
 
 	for _, fsys := range []fs.FS{nil, os.DirFS(".")} {
 		t.Run("", func(t *testing.T) {
-			tmp := memdb.TestDB(t)
+			dsn := memdb.TestDB(t)
 
-			db, err := driver.Open(tmp, func(c *sqlite3.Conn) error {
+			db, err := driver.Open(dsn, func(c *sqlite3.Conn) error {
 				fileio.RegisterFS(c, fsys)
 				return nil
 			})

ext/fileio/fsdir_test.go

@@ -21,9 +21,9 @@ func Test_fsdir(t *testing.T) {
 
 	for _, fsys := range []fs.FS{nil, os.DirFS(".")} {
 		t.Run("", func(t *testing.T) {
-			tmp := memdb.TestDB(t)
+			dsn := memdb.TestDB(t)
 
-			db, err := driver.Open(tmp, func(c *sqlite3.Conn) error {
+			db, err := driver.Open(dsn, func(c *sqlite3.Conn) error {
 				fileio.RegisterFS(c, fsys)
 				return nil
 			})

ext/fileio/write_test.go

@@ -15,9 +15,9 @@ import (
 
 func Test_writefile(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, Register)
+	db, err := driver.Open(dsn, Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/hash/hash_test.go

@@ -4,6 +4,7 @@ import (
 	_ "crypto/md5"
 	_ "crypto/sha1"
 	_ "crypto/sha256"
+	_ "crypto/sha3"
 	_ "crypto/sha512"
 	"testing"
 
@@ -11,7 +12,6 @@ import (
 	_ "golang.org/x/crypto/blake2s"
 	_ "golang.org/x/crypto/md4"
 	_ "golang.org/x/crypto/ripemd160"
-	_ "golang.org/x/crypto/sha3"
 
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
@@ -21,7 +21,7 @@ import (
 
 func TestRegister(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
 	tests := []struct {
 		name string
@@ -55,7 +55,7 @@ func TestRegister(t *testing.T) {
 		{"blake2b('', 256)", "0E5751C026E543B2E8AB2EB06099DAA1D1E5DF47778F7787FAAB45CDF12FE3A8"},
 	}
 
-	db, err := driver.Open(tmp, Register)
+	db, err := driver.Open(dsn, Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/ipaddr/ipaddr_test.go

@@ -12,9 +12,9 @@ import (
 
 func TestRegister(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, ipaddr.Register)
+	db, err := driver.Open(dsn, ipaddr.Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/lines/lines_test.go

@@ -67,9 +67,9 @@ func Example() {
 
 func Test_lines(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, lines.Register)
+	db, err := driver.Open(dsn, lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -98,9 +98,9 @@ func Test_lines(t *testing.T) {
 
 func Test_lines_error(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, lines.Register)
+	db, err := driver.Open(dsn, lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -123,9 +123,9 @@ func Test_lines_error(t *testing.T) {
 
 func Test_lines_read(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, lines.Register)
+	db, err := driver.Open(dsn, lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -155,9 +155,9 @@ func Test_lines_read(t *testing.T) {
 
 func Test_lines_test(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, lines.Register)
+	db, err := driver.Open(dsn, lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}

ext/regexp/regexp_test.go

@@ -15,9 +15,9 @@ import (
 
 func TestRegister(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, Register)
+	db, err := driver.Open(dsn, Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -80,9 +80,9 @@ func TestRegister(t *testing.T) {
 
 func TestRegister_errors(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, Register)
+	db, err := driver.Open(dsn, Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -107,9 +107,9 @@ func TestRegister_errors(t *testing.T) {
 
 func TestRegister_pointer(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, Register)
+	db, err := driver.Open(dsn, Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/uuid/uuid.go

@@ -194,7 +194,7 @@ func timestamp(ctx sqlite3.Context, arg ...sqlite3.Value) {
 		switch u.Version() {
 		case 1, 2, 6, 7:
 			ctx.ResultTime(
-				time.Unix(u.Time().UnixTime()),
+				time.Unix(u.Time().UnixTime()).UTC(),
 				sqlite3.TimeFormatDefault)
 		}
 	}

ext/uuid/uuid_test.go

@@ -14,9 +14,9 @@ import (
 
 func Test_generate(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, Register)
+	db, err := driver.Open(dsn, Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -153,9 +153,9 @@ func Test_generate(t *testing.T) {
 
 func Test_convert(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, Register)
+	db, err := driver.Open(dsn, Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/zorder/zorder_test.go

@@ -14,9 +14,9 @@ import (
 
 func Test_zorder(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, zorder.Register)
+	db, err := driver.Open(dsn, zorder.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -59,9 +59,9 @@ func Test_zorder(t *testing.T) {
 
 func Test_unzorder(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, zorder.Register)
+	db, err := driver.Open(dsn, zorder.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -87,9 +87,9 @@ func Test_unzorder(t *testing.T) {
 
 func Test_zorder_error(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, zorder.Register)
+	db, err := driver.Open(dsn, zorder.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -116,9 +116,9 @@ func Test_zorder_error(t *testing.T) {
 
 func Test_unzorder_error(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, zorder.Register)
+	db, err := driver.Open(dsn, zorder.Register)
 	if err != nil {
 		t.Fatal(err)
 	}

go.mod

@@ -1,24 +1,22 @@
 module github.com/ncruces/go-sqlite3
 
-go 1.23.0
-
-toolchain go1.24.0
+go 1.24.0
 
 require (
-	github.com/ncruces/aa v0.3.0
 	github.com/ncruces/julianday v1.0.0
-	github.com/ncruces/sort v0.1.5
+	github.com/ncruces/sort v0.1.6
+	github.com/ncruces/wbt v0.2.0
 	github.com/tetratelabs/wazero v1.9.0
-	golang.org/x/crypto v0.41.0
-	golang.org/x/sys v0.35.0
+	golang.org/x/sys v0.36.0
 )
 
 require (
 	github.com/dchest/siphash v1.2.3 // ext/bloom
 	github.com/google/uuid v1.6.0 // ext/uuid
 	github.com/psanford/httpreadat v0.1.0 // example
-	golang.org/x/sync v0.16.0 // test
-	golang.org/x/text v0.28.0 // ext/unicode
+	golang.org/x/crypto v0.42.0 // vfs/adiantum vfs/xts
+	golang.org/x/sync v0.17.0 // test
+	golang.org/x/text v0.29.0 // ext/unicode
 	lukechampine.com/adiantum v1.1.1 // vfs/adiantum
 )
 

go.sum

@@ -2,23 +2,23 @@ github.com/dchest/siphash v1.2.3 h1:QXwFc8cFOR2dSa/gE6o/HokBMWtLUaNDVd+22aKHeEA=
 github.com/dchest/siphash v1.2.3/go.mod h1:0NvQU092bT0ipiFN++/rXm69QG9tVxLAlQHIXMPAkHc=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/ncruces/aa v0.3.0 h1:6NPcK3jsyPWRZBZWCyF7c4IzEQX4eJtkKJBA+IRKTkQ=
-github.com/ncruces/aa v0.3.0/go.mod h1:ctOw1LVqfuqzqg2S9LlR045bLAiXtaTiPMCL3zzl7Ik=
 github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M=
 github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
-github.com/ncruces/sort v0.1.5 h1:fiFWXXAqKI8QckPf/6hu/bGFwcEPrirIOFaJqWujs4k=
-github.com/ncruces/sort v0.1.5/go.mod h1:obJToO4rYr6VWP0Uw5FYymgYGt3Br4RXcs/JdKaXAPk=
+github.com/ncruces/sort v0.1.6 h1:TrsJfGRH1AoWoaeB4/+gCohot9+cA6u/INaH5agIhNk=
+github.com/ncruces/sort v0.1.6/go.mod h1:obJToO4rYr6VWP0Uw5FYymgYGt3Br4RXcs/JdKaXAPk=
+github.com/ncruces/wbt v0.2.0 h1:Q9zlKOBSZc7Yy/R2cGa35g6RKUUE3BjNIW3tfGC4F04=
+github.com/ncruces/wbt v0.2.0/go.mod h1:DtF92amvMxH69EmBFUSFWRDAlo6hOEfoNQnClxj9C/c=
 github.com/psanford/httpreadat v0.1.0 h1:VleW1HS2zO7/4c7c7zNl33fO6oYACSagjJIyMIwZLUE=
 github.com/psanford/httpreadat v0.1.0/go.mod h1:Zg7P+TlBm3bYbyHTKv/EdtSJZn3qwbPwpfZ/I9GKCRE=
 github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
 github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
-golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4=
-golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc=
-golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
-golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
-golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
-golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
+golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
+golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
+golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
+golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk=
+golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=
 lukechampine.com/adiantum v1.1.1 h1:4fp6gTxWCqpEbLy40ExiYDDED3oUNWx5cTqBCtPdZqA=
 lukechampine.com/adiantum v1.1.1/go.mod h1:LrAYVnTYLnUtE/yMp5bQr0HstAf060YUF8nM0B6+rUw=

gormlite/go.mod

@@ -1,12 +1,10 @@
 module github.com/ncruces/go-sqlite3/gormlite
 
-go 1.23.0
-
-toolchain go1.24.0
+go 1.24.0
 
 require (
-	github.com/ncruces/go-sqlite3 v0.27.1
-	gorm.io/gorm v1.30.1
+	github.com/ncruces/go-sqlite3 v0.29.0
+	gorm.io/gorm v1.30.5
 )
 
 require (
@@ -14,6 +12,6 @@ require (
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/ncruces/julianday v1.0.0 // indirect
 	github.com/tetratelabs/wazero v1.9.0 // indirect
-	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/sys v0.36.0 // indirect
+	golang.org/x/text v0.29.0 // indirect
 )

gormlite/go.sum

@@ -2,15 +2,15 @@ github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
 github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
-github.com/ncruces/go-sqlite3 v0.27.1 h1:suqlM7xhSyDVMV9RgX99MCPqt9mB6YOCzHZuiI36K34=
-github.com/ncruces/go-sqlite3 v0.27.1/go.mod h1:gpF5s+92aw2MbDmZK0ZOnCdFlpe11BH20CTspVqri0c=
+github.com/ncruces/go-sqlite3 v0.29.0 h1:1tsLiagCoqZEfcHDeKsNSv5jvrY/Iu393pAnw2wLNJU=
+github.com/ncruces/go-sqlite3 v0.29.0/go.mod h1:r1hSvYKPNJ+OlUA1O3r8o9LAawzPAlqeZiIdxTBBBJ0=
 github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M=
 github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
 github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
 github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
-golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
-golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
-gorm.io/gorm v1.30.1 h1:lSHg33jJTBxs2mgJRfRZeLDG+WZaHYCk3Wtfl6Ngzo4=
-gorm.io/gorm v1.30.1/go.mod h1:8Z33v652h4//uMA76KjeDH8mJXPm1QNCYrMeatR0DOE=
+golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
+golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk=
+golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=
+gorm.io/gorm v1.30.5 h1:dvEfYwxL+i+xgCNSGGBT1lDjCzfELK8fHZxL3Ee9X0s=
+gorm.io/gorm v1.30.5/go.mod h1:8Z33v652h4//uMA76KjeDH8mJXPm1QNCYrMeatR0DOE=

gormlite/sqlite_test.go

@@ -14,10 +14,10 @@ import (
 )
 
 func TestDialector(t *testing.T) {
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
 	// Custom connection with a custom function called "my_custom_function".
-	db, err := driver.Open(tmp, func(conn *sqlite3.Conn) error {
+	db, err := driver.Open(dsn, func(conn *sqlite3.Conn) error {
 		return conn.CreateFunction("my_custom_function", 0, sqlite3.DETERMINISTIC,
 			func(ctx sqlite3.Context, arg ...sqlite3.Value) {
 				ctx.ResultText("my-result")
@@ -36,14 +36,14 @@ func TestDialector(t *testing.T) {
 	}{
 		{
 			description:  "Default driver",
-			dialector:    Open(tmp),
+			dialector:    Open(dsn),
 			openSuccess:  true,
 			query:        "SELECT 1",
 			querySuccess: true,
 		},
 		{
 			description:  "Custom function",
-			dialector:    Open(tmp),
+			dialector:    Open(dsn),
 			openSuccess:  true,
 			query:        "SELECT my_custom_function()",
 			querySuccess: false,

gormlite/test.sh

@@ -7,7 +7,7 @@ rm -rf gorm/ tests/
 go work use -r .
 go test
 
-git clone --branch v1.30.1 --filter=blob:none https://github.com/go-gorm/gorm.git
+git clone --branch v1.30.5 --filter=blob:none https://github.com/go-gorm/gorm.git
 mv gorm/tests tests
 rm -rf gorm/
 

internal/alloc/alloc_unix.go

@@ -9,24 +9,31 @@ import (
 	"golang.org/x/sys/unix"
 )
 
-func NewMemory(_, max uint64) experimental.LinearMemory {
+func NewMemory(cap, max uint64) experimental.LinearMemory {
 	// Round up to the page size.
 	rnd := uint64(unix.Getpagesize() - 1)
-	max = (max + rnd) &^ rnd
+	res := (max + rnd) &^ rnd
 
-	if max > math.MaxInt {
-		// This ensures int(max) overflows to a negative value,
+	if res > math.MaxInt {
+		// This ensures int(res) overflows to a negative value,
 		// and unix.Mmap returns EINVAL.
-		max = math.MaxUint64
+		res = math.MaxUint64
 	}
 
-	// Reserve max bytes of address space, to ensure we won't need to move it.
+	com := res
+	prot := unix.PROT_READ | unix.PROT_WRITE
+	if cap < max { // Commit memory only if cap=max.
+		com = 0
+		prot = unix.PROT_NONE
+	}
+
+	// Reserve res bytes of address space, to ensure we won't need to move it.
 	// A protected, private, anonymous mapping should not commit memory.
-	b, err := unix.Mmap(-1, 0, int(max), unix.PROT_NONE, unix.MAP_PRIVATE|unix.MAP_ANON)
+	b, err := unix.Mmap(-1, 0, int(res), prot, unix.MAP_PRIVATE|unix.MAP_ANON)
 	if err != nil {
 		panic(err)
 	}
-	return &mmappedMemory{buf: b[:0]}
+	return &mmappedMemory{buf: b[:com]}
 }
 
 // The slice covers the entire mmapped memory:
@@ -40,9 +47,11 @@ func (m *mmappedMemory) Reallocate(size uint64) []byte {
 	com := uint64(len(m.buf))
 	res := uint64(cap(m.buf))
 	if com < size && size <= res {
-		// Round up to the page size.
+		// Grow geometrically, round up to the page size.
 		rnd := uint64(unix.Getpagesize() - 1)
-		new := (size + rnd) &^ rnd
+		new := com + com>>3
+		new = min(max(size, new), res)
+		new = (new + rnd) &^ rnd
 
 		// Commit additional memory up to new bytes.
 		err := unix.Mprotect(m.buf[com:new], unix.PROT_READ|unix.PROT_WRITE)
@@ -50,8 +59,7 @@ func (m *mmappedMemory) Reallocate(size uint64) []byte {
 			return nil
 		}
 
-		// Update committed memory.
-		m.buf = m.buf[:new]
+		m.buf = m.buf[:new] // Update committed memory.
 	}
 	// Limit returned capacity because bytes beyond
 	// len(m.buf) have not yet been committed.

internal/alloc/alloc_windows.go

@@ -9,20 +9,26 @@ import (
 	"golang.org/x/sys/windows"
 )
 
-func NewMemory(_, max uint64) experimental.LinearMemory {
+func NewMemory(cap, max uint64) experimental.LinearMemory {
 	// Round up to the page size.
 	rnd := uint64(windows.Getpagesize() - 1)
-	max = (max + rnd) &^ rnd
+	res := (max + rnd) &^ rnd
 
-	if max > math.MaxInt {
-		// This ensures uintptr(max) overflows to a large value,
+	if res > math.MaxInt {
+		// This ensures uintptr(res) overflows to a large value,
 		// and windows.VirtualAlloc returns an error.
-		max = math.MaxUint64
+		res = math.MaxUint64
 	}
 
-	// Reserve max bytes of address space, to ensure we won't need to move it.
-	// This does not commit memory.
-	r, err := windows.VirtualAlloc(0, uintptr(max), windows.MEM_RESERVE, windows.PAGE_READWRITE)
+	com := res
+	kind := windows.MEM_COMMIT
+	if cap < max { // Commit memory only if cap=max.
+		com = 0
+		kind = windows.MEM_RESERVE
+	}
+
+	// Reserve res bytes of address space, to ensure we won't need to move it.
+	r, err := windows.VirtualAlloc(0, uintptr(res), uint32(kind), windows.PAGE_READWRITE)
 	if err != nil {
 		panic(err)
 	}
@@ -30,8 +36,9 @@ func NewMemory(_, max uint64) experimental.LinearMemory {
 	mem := virtualMemory{addr: r}
 	// SliceHeader, although deprecated, avoids a go vet warning.
 	sh := (*reflect.SliceHeader)(unsafe.Pointer(&mem.buf))
-	sh.Cap = int(max)
 	sh.Data = r
+	sh.Len = int(com)
+	sh.Cap = int(res)
 	return &mem
 }
 
@@ -47,9 +54,11 @@ func (m *virtualMemory) Reallocate(size uint64) []byte {
 	com := uint64(len(m.buf))
 	res := uint64(cap(m.buf))
 	if com < size && size <= res {
-		// Round up to the page size.
+		// Grow geometrically, round up to the page size.
 		rnd := uint64(windows.Getpagesize() - 1)
-		new := (size + rnd) &^ rnd
+		new := com + com>>3
+		new = min(max(size, new), res)
+		new = (new + rnd) &^ rnd
 
 		// Commit additional memory up to new bytes.
 		_, err := windows.VirtualAlloc(m.addr, uintptr(new), windows.MEM_COMMIT, windows.PAGE_READWRITE)
@@ -57,8 +66,7 @@ func (m *virtualMemory) Reallocate(size uint64) []byte {
 			return nil
 		}
 
-		// Update committed memory.
-		m.buf = m.buf[:new]
+		m.buf = m.buf[:new] // Update committed memory.
 	}
 	// Limit returned capacity because bytes beyond
 	// len(m.buf) have not yet been committed.

internal/util/json.go

@@ -1,3 +1,5 @@
+//go:build !goexperiment.jsonv2
+
 package util
 
 import (

internal/util/json_v2.go

@@ -0,0 +1,52 @@
+//go:build goexperiment.jsonv2
+
+package util
+
+import (
+	"encoding/json/v2"
+	"math"
+	"strconv"
+	"time"
+	"unsafe"
+)
+
+type JSON struct{ Value any }
+
+func (j JSON) Scan(value any) error {
+	var buf []byte
+
+	switch v := value.(type) {
+	case []byte:
+		buf = v
+	case string:
+		buf = unsafe.Slice(unsafe.StringData(v), len(v))
+	case int64:
+		buf = strconv.AppendInt(nil, v, 10)
+	case float64:
+		buf = AppendNumber(nil, v)
+	case time.Time:
+		buf = append(buf, '"')
+		buf = v.AppendFormat(buf, time.RFC3339Nano)
+		buf = append(buf, '"')
+	case nil:
+		buf = []byte("null")
+	default:
+		panic(AssertErr())
+	}
+
+	return json.Unmarshal(buf, j.Value)
+}
+
+func AppendNumber(dst []byte, f float64) []byte {
+	switch {
+	case math.IsNaN(f):
+		dst = append(dst, "null"...)
+	case math.IsInf(f, 1):
+		dst = append(dst, "9.0e999"...)
+	case math.IsInf(f, -1):
+		dst = append(dst, "-9.0e999"...)
+	default:
+		return strconv.AppendFloat(dst, f, 'g', -1, 64)
+	}
+	return dst
+}

json.go

@@ -1,6 +1,13 @@
+//go:build !goexperiment.jsonv2
+
 package sqlite3
 
-import "github.com/ncruces/go-sqlite3/internal/util"
+import (
+	"encoding/json"
+	"strconv"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+)
 
 // JSON returns a value that can be used as an argument to
 // [database/sql.DB.Exec], [database/sql.Row.Scan] and similar methods to
@@ -10,3 +17,77 @@ import "github.com/ncruces/go-sqlite3/internal/util"
 func JSON(value any) any {
 	return util.JSON{Value: value}
 }
+
+// ResultJSON sets the result of the function to the JSON encoding of value.
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultJSON(value any) {
+	err := json.NewEncoder(callbackWriter(func(p []byte) (int, error) {
+		ctx.ResultRawText(p[:len(p)-1]) // remove the newline
+		return 0, nil
+	})).Encode(value)
+
+	if err != nil {
+		ctx.ResultError(err)
+		return // notest
+	}
+}
+
+// BindJSON binds the JSON encoding of value to the prepared statement.
+// The leftmost SQL parameter has an index of 1.
+//
+// https://sqlite.org/c3ref/bind_blob.html
+func (s *Stmt) BindJSON(param int, value any) error {
+	return json.NewEncoder(callbackWriter(func(p []byte) (int, error) {
+		return 0, s.BindRawText(param, p[:len(p)-1]) // remove the newline
+	})).Encode(value)
+}
+
+// ColumnJSON parses the JSON-encoded value of the result column
+// and stores it in the value pointed to by ptr.
+// The leftmost column of the result set has the index 0.
+//
+// https://sqlite.org/c3ref/column_blob.html
+func (s *Stmt) ColumnJSON(col int, ptr any) error {
+	var data []byte
+	switch s.ColumnType(col) {
+	case NULL:
+		data = []byte("null")
+	case TEXT:
+		data = s.ColumnRawText(col)
+	case BLOB:
+		data = s.ColumnRawBlob(col)
+	case INTEGER:
+		data = strconv.AppendInt(nil, s.ColumnInt64(col), 10)
+	case FLOAT:
+		data = util.AppendNumber(nil, s.ColumnFloat(col))
+	default:
+		panic(util.AssertErr())
+	}
+	return json.Unmarshal(data, ptr)
+}
+
+// JSON parses a JSON-encoded value
+// and stores the result in the value pointed to by ptr.
+func (v Value) JSON(ptr any) error {
+	var data []byte
+	switch v.Type() {
+	case NULL:
+		data = []byte("null")
+	case TEXT:
+		data = v.RawText()
+	case BLOB:
+		data = v.RawBlob()
+	case INTEGER:
+		data = strconv.AppendInt(nil, v.Int64(), 10)
+	case FLOAT:
+		data = util.AppendNumber(nil, v.Float())
+	default:
+		panic(util.AssertErr())
+	}
+	return json.Unmarshal(data, ptr)
+}
+
+type callbackWriter func(p []byte) (int, error)
+
+func (fn callbackWriter) Write(p []byte) (int, error) { return fn(p) }

json_v2.go

@@ -0,0 +1,113 @@
+//go:build goexperiment.jsonv2
+
+package sqlite3
+
+import (
+	"encoding/json/v2"
+	"strconv"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+)
+
+// JSON returns a value that can be used as an argument to
+// [database/sql.DB.Exec], [database/sql.Row.Scan] and similar methods to
+// store value as JSON, or decode JSON into value.
+// JSON should NOT be used with [Stmt.BindJSON], [Stmt.ColumnJSON],
+// [Value.JSON], or [Context.ResultJSON].
+func JSON(value any) any {
+	return util.JSON{Value: value}
+}
+
+// ResultJSON sets the result of the function to the JSON encoding of value.
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultJSON(value any) {
+	w := bytesWriter{sqlite: ctx.c.sqlite}
+	if err := json.MarshalWrite(&w, value); err != nil {
+		ctx.c.free(w.ptr)
+		ctx.ResultError(err)
+		return // notest
+	}
+	ctx.c.call("sqlite3_result_text_go",
+		stk_t(ctx.handle), stk_t(w.ptr), stk_t(len(w.buf)))
+}
+
+// BindJSON binds the JSON encoding of value to the prepared statement.
+// The leftmost SQL parameter has an index of 1.
+//
+// https://sqlite.org/c3ref/bind_blob.html
+func (s *Stmt) BindJSON(param int, value any) error {
+	w := bytesWriter{sqlite: s.c.sqlite}
+	if err := json.MarshalWrite(&w, value); err != nil {
+		s.c.free(w.ptr)
+		return err
+	}
+	rc := res_t(s.c.call("sqlite3_bind_text_go",
+		stk_t(s.handle), stk_t(param),
+		stk_t(w.ptr), stk_t(len(w.buf))))
+	return s.c.error(rc)
+}
+
+// ColumnJSON parses the JSON-encoded value of the result column
+// and stores it in the value pointed to by ptr.
+// The leftmost column of the result set has the index 0.
+//
+// https://sqlite.org/c3ref/column_blob.html
+func (s *Stmt) ColumnJSON(col int, ptr any) error {
+	var data []byte
+	switch s.ColumnType(col) {
+	case NULL:
+		data = []byte("null")
+	case TEXT:
+		data = s.ColumnRawText(col)
+	case BLOB:
+		data = s.ColumnRawBlob(col)
+	case INTEGER:
+		data = strconv.AppendInt(nil, s.ColumnInt64(col), 10)
+	case FLOAT:
+		data = util.AppendNumber(nil, s.ColumnFloat(col))
+	default:
+		panic(util.AssertErr())
+	}
+	return json.Unmarshal(data, ptr)
+}
+
+// JSON parses a JSON-encoded value
+// and stores the result in the value pointed to by ptr.
+func (v Value) JSON(ptr any) error {
+	var data []byte
+	switch v.Type() {
+	case NULL:
+		data = []byte("null")
+	case TEXT:
+		data = v.RawText()
+	case BLOB:
+		data = v.RawBlob()
+	case INTEGER:
+		data = strconv.AppendInt(nil, v.Int64(), 10)
+	case FLOAT:
+		data = util.AppendNumber(nil, v.Float())
+	default:
+		panic(util.AssertErr())
+	}
+	return json.Unmarshal(data, ptr)
+}
+
+type bytesWriter struct {
+	*sqlite
+	buf []byte
+	ptr ptr_t
+}
+
+func (b *bytesWriter) Write(p []byte) (n int, err error) {
+	if len(p) > cap(b.buf)-len(b.buf) {
+		want := int64(len(b.buf)) + int64(len(p))
+		grow := int64(cap(b.buf))
+		grow += grow >> 1
+		want = max(want, grow)
+		b.ptr = b.realloc(b.ptr, want)
+		b.buf = util.View(b.mod, b.ptr, want)[:len(b.buf)]
+	}
+	b.buf = append(b.buf, p...)
+	return len(p), nil
+}

sqlite.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"math/bits"
 	"os"
+	"strings"
 	"sync"
 	"unsafe"
 
@@ -128,11 +129,10 @@ func (sqlt *sqlite) error(rc res_t, handle ptr_t, sql ...string) error {
 		var msg, query string
 		if ptr := ptr_t(sqlt.call("sqlite3_errmsg", stk_t(handle))); ptr != 0 {
 			msg = util.ReadString(sqlt.mod, ptr, _MAX_LENGTH)
-			switch {
-			case msg == "not an error":
-				msg = ""
-			case msg == util.ErrorCodeString(uint32(rc))[len("sqlite3: "):]:
+			if msg == "not an error" {
 				msg = ""
+			} else {
+				msg = strings.TrimPrefix(msg, util.ErrorCodeString(uint32(rc))[len("sqlite3: "):])
 			}
 		}
 

sqlite3/download.sh

@@ -4,6 +4,15 @@ set -euo pipefail
 cd -P -- "$(dirname -- "$0")"
 
 curl -#OL "https://sqlite.org/2025/sqlite-amalgamation-3500400.zip"
+
+# Verify download.
+if hash=$(openssl dgst -sha3-256 sqlite-amalgamation-*.zip); then
+  if ! [[ $hash =~ f131b68e6ba5fb891cc13ebb5ff9555054c77294cb92d8d1268bad5dba4fa2a1 ]]; then
+    echo $hash
+    exit 1
+  fi
+fi 2> /dev/null
+
 unzip -d . sqlite-amalgamation-*.zip
 mv sqlite-amalgamation-*/sqlite3.c .
 mv sqlite-amalgamation-*/sqlite3.h .

sqlite3/libc/build.sh

@@ -43,10 +43,11 @@ EOF
 	-Wl,--export=qsort
 
 "$BINARYEN/wasm-ctor-eval" -g -c _initialize libc.wasm -o libc.tmp
-"$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
-	libc.tmp -o libc.wasm \
+"$BINARYEN/wasm-opt" -g libc.tmp -o libc.wasm \
+	--low-memory-unused --generate-global-effects --converge -O3 \
 	--enable-mutable-globals --enable-nontrapping-float-to-int \
 	--enable-simd --enable-bulk-memory --enable-sign-ext \
-	--enable-reference-types --enable-multivalue
+	--enable-reference-types --enable-multivalue \
+	--strip --strip-debug --strip-producers
 
 "$BINARYEN/wasm-dis" -o libc.wat libc.wasm

sqlite3/libc/libc_test.go

@@ -75,8 +75,7 @@ func Benchmark_memset(b *testing.B) {
 	clear(memory)
 
 	b.SetBytes(size)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		call(memset, ptr1, 3, size)
 	}
 }
@@ -86,8 +85,7 @@ func Benchmark_memcpy(b *testing.B) {
 	fill(memory[ptr2:ptr2+size], 5)
 
 	b.SetBytes(size)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		call(memcpy, ptr1, ptr2, size)
 	}
 }
@@ -97,8 +95,7 @@ func Benchmark_strlen(b *testing.B) {
 	fill(memory[ptr1:ptr1+size-1], 5)
 
 	b.SetBytes(size)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		call(strlen, ptr1)
 	}
 }
@@ -109,8 +106,7 @@ func Benchmark_memchr(b *testing.B) {
 	fill(memory[ptr1+size/2:ptr1+size], 5)
 
 	b.SetBytes(size/2 + 1)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		call(memchr, ptr1, 5, size)
 	}
 }
@@ -121,8 +117,7 @@ func Benchmark_strchr(b *testing.B) {
 	fill(memory[ptr1+size/2:ptr1+size-1], 5)
 
 	b.SetBytes(size/2 + 1)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		call(strchr, ptr1, 5)
 	}
 }
@@ -133,8 +128,7 @@ func Benchmark_strrchr(b *testing.B) {
 	fill(memory[ptr1+size/2:ptr1+size-1], 7)
 
 	b.SetBytes(size/2 + 1)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		call(strrchr, ptr1, 5)
 	}
 }
@@ -146,8 +140,7 @@ func Benchmark_memcmp(b *testing.B) {
 	fill(memory[ptr2+size/2:ptr2+size], 5)
 
 	b.SetBytes(size/2 + 1)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		call(memcmp, ptr1, ptr2, size)
 	}
 }
@@ -162,8 +155,7 @@ func Benchmark_strspn(b *testing.B) {
 	memory[ptr2+3] = 9
 
 	b.SetBytes(size)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		call(strspn, ptr1, ptr2)
 	}
 }
@@ -176,8 +168,7 @@ func Benchmark_strcspn(b *testing.B) {
 	memory[ptr2+1] = 9
 
 	b.SetBytes(size)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		call(strcspn, ptr1, ptr2)
 	}
 }

sqlite3/tools.sh

@@ -27,7 +27,7 @@ elif [[ "$OSTYPE" == "darwin"* ]]; then
 fi
 
 WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-27/wasi-sdk-27.0-$WASI_SDK.tar.gz"
-BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_123/binaryen-version_123-$BINARYEN.tar.gz"
+BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_124/binaryen-version_124-$BINARYEN.tar.gz"
 
 # Download tools
 mkdir -p "$ROOT/tools"

stmt.go

@@ -1,9 +1,7 @@
 package sqlite3
 
 import (
-	"encoding/json"
 	"math"
-	"strconv"
 	"time"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
@@ -362,16 +360,6 @@ func (s *Stmt) BindPointer(param int, ptr any) error {
 	return s.c.error(rc)
 }
 
-// BindJSON binds the JSON encoding of value to the prepared statement.
-// The leftmost SQL parameter has an index of 1.
-//
-// https://sqlite.org/c3ref/bind_blob.html
-func (s *Stmt) BindJSON(param int, value any) error {
-	return json.NewEncoder(callbackWriter(func(p []byte) (int, error) {
-		return 0, s.BindRawText(param, p[:len(p)-1]) // remove the newline
-	})).Encode(value)
-}
-
 // BindValue binds a copy of value to the prepared statement.
 // The leftmost SQL parameter has an index of 1.
 //
@@ -598,30 +586,6 @@ func (s *Stmt) columnRawBytes(col int, ptr ptr_t, nul int32) []byte {
 	return util.View(s.c.mod, ptr, int64(n+nul))[:n]
 }
 
-// ColumnJSON parses the JSON-encoded value of the result column
-// and stores it in the value pointed to by ptr.
-// The leftmost column of the result set has the index 0.
-//
-// https://sqlite.org/c3ref/column_blob.html
-func (s *Stmt) ColumnJSON(col int, ptr any) error {
-	var data []byte
-	switch s.ColumnType(col) {
-	case NULL:
-		data = []byte("null")
-	case TEXT:
-		data = s.ColumnRawText(col)
-	case BLOB:
-		data = s.ColumnRawBlob(col)
-	case INTEGER:
-		data = strconv.AppendInt(nil, s.ColumnInt64(col), 10)
-	case FLOAT:
-		data = util.AppendNumber(nil, s.ColumnFloat(col))
-	default:
-		panic(util.AssertErr())
-	}
-	return json.Unmarshal(data, ptr)
-}
-
 // ColumnValue returns the unprotected value of the result column.
 // The leftmost column of the result set has the index 0.
 //
@@ -748,7 +712,3 @@ func (s *Stmt) columns(count int64) ([]byte, ptr_t, error) {
 
 	return util.View(s.c.mod, typePtr, count), dataPtr, nil
 }
-
-type callbackWriter func(p []byte) (int, error)
-
-func (fn callbackWriter) Write(p []byte) (int, error) { return fn(p) }

tests/blob_test.go

@@ -45,10 +45,7 @@ func TestBlob(t *testing.T) {
 	}
 
 	var data [1280]byte
-	_, err = rand.Read(data[:])
-	if err != nil {
-		t.Fatal(err)
-	}
+	rand.Read(data[:])
 
 	_, err = blob.Write(data[:size/2])
 	if err != nil {

tests/config_test.go

@@ -388,11 +388,11 @@ func TestConn_Trace(t *testing.T) {
 
 func TestConn_AutoVacuumPages(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t, url.Values{
+	dsn := memdb.TestDB(t, url.Values{
 		"_pragma": {"auto_vacuum(full)"},
 	})
 
-	db, err := sqlite3.Open(tmp)
+	db, err := sqlite3.Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}

tests/conn_test.go

@@ -163,7 +163,7 @@ func TestConn_SetInterrupt(t *testing.T) {
 	}
 	defer db.Close()
 
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx, cancel := context.WithCancel(t.Context())
 	db.SetInterrupt(ctx)
 
 	// Interrupt doesn't interrupt this.
@@ -202,9 +202,7 @@ func TestConn_SetInterrupt(t *testing.T) {
 		t.Errorf("got %v, want sqlite3.INTERRUPT", err)
 	}
 
-	ctx, cancel = context.WithCancel(context.Background())
-	defer cancel()
-	db.SetInterrupt(ctx)
+	db.SetInterrupt(t.Context())
 
 	// Interrupting can be cleared.
 	err = db.Exec(`SELECT 1`)
@@ -212,9 +210,8 @@ func TestConn_SetInterrupt(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	db.SetInterrupt(ctx)
-	if got := db.GetInterrupt(); got != ctx {
-		t.Errorf("got %v, want %v", got, ctx)
+	if got := db.GetInterrupt(); got != t.Context() {
+		t.Errorf("got %v, want %v", got, t.Context())
 	}
 }
 

tests/driver_test.go

@@ -1,7 +1,6 @@
 package tests
 
 import (
-	"context"
 	"testing"
 
 	"github.com/ncruces/go-sqlite3"
@@ -13,12 +12,9 @@ import (
 
 func TestDriver(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	db, err := driver.Open(tmp, nil, func(c *sqlite3.Conn) error {
+	db, err := driver.Open(dsn, nil, func(c *sqlite3.Conn) error {
 		return c.Exec(`PRAGMA optimize`)
 	})
 	if err != nil {
@@ -26,13 +22,13 @@ func TestDriver(t *testing.T) {
 	}
 	defer db.Close()
 
-	conn, err := db.Conn(ctx)
+	conn, err := db.Conn(t.Context())
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer conn.Close()
 
-	res, err := conn.ExecContext(ctx,
+	res, err := conn.ExecContext(t.Context(),
 		`CREATE TABLE users (id INTEGER PRIMARY KEY NOT NULL, name VARCHAR(10))`)
 	if err != nil {
 		t.Fatal(err)
@@ -52,7 +48,7 @@ func TestDriver(t *testing.T) {
 		t.Errorf("got %d want 0", changes)
 	}
 
-	res, err = conn.ExecContext(ctx,
+	res, err = conn.ExecContext(t.Context(),
 		`INSERT INTO users (id, name) VALUES (0, 'go'), (1, 'zig'), (2, 'whatever')`)
 	if err != nil {
 		t.Fatal(err)
@@ -65,7 +61,7 @@ func TestDriver(t *testing.T) {
 		t.Errorf("got %d want 3", changes)
 	}
 
-	stmt, err := conn.PrepareContext(context.Background(),
+	stmt, err := conn.PrepareContext(t.Context(),
 		`SELECT id, name FROM users`)
 	if err != nil {
 		t.Fatal(err)

tests/json_test.go

@@ -1,7 +1,6 @@
 package tests
 
 import (
-	"context"
 	"encoding/json"
 	"math"
 	"testing"
@@ -17,31 +16,28 @@ import (
 
 func TestJSON(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	db, err := driver.Open(tmp)
+	db, err := driver.Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db.Close()
 
-	conn, err := db.Conn(ctx)
+	conn, err := db.Conn(t.Context())
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer conn.Close()
 
-	_, err = conn.ExecContext(ctx, `CREATE TABLE test (col)`)
+	_, err = conn.ExecContext(t.Context(), `CREATE TABLE test (col)`)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	reference := time.Date(2013, 10, 7, 4, 23, 19, 120_000_000, time.FixedZone("", -4*3600))
 
-	_, err = conn.ExecContext(ctx,
+	_, err = conn.ExecContext(t.Context(),
 		`INSERT INTO test (col) VALUES (?), (?), (?), (?)`,
 		nil, 1, math.Pi, reference,
 	)
@@ -49,7 +45,7 @@ func TestJSON(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	_, err = conn.ExecContext(ctx,
+	_, err = conn.ExecContext(t.Context(),
 		`INSERT INTO test (col) VALUES (?), (?), (?), (?)`,
 		sqlite3.JSON(math.Pi), sqlite3.JSON(false),
 		julianday.Format(reference), sqlite3.JSON([]string{}))
@@ -57,7 +53,7 @@ func TestJSON(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	rows, err := conn.QueryContext(ctx, "SELECT * FROM test")
+	rows, err := conn.QueryContext(t.Context(), "SELECT * FROM test")
 	if err != nil {
 		t.Fatal(err)
 	}

tests/parallel/parallel_test.go

@@ -107,9 +107,9 @@ func Test_mvcc(t *testing.T) {
 		iter = 5000
 	}
 
-	mvcc.Create("test.db", "")
-	name := "file:/test.db?vfs=mvcc" +
-		"&_pragma=busy_timeout(10000)"
+	name := mvcc.TestDB(t, mvcc.Snapshot{}, url.Values{
+		"_pragma": {"busy_timeout(10000)"},
+	})
 	createDB(t, name)
 	testParallel(t, name, iter)
 	testIntegrity(t, name)
@@ -330,9 +330,9 @@ func Benchmark_memdb(b *testing.B) {
 }
 
 func Benchmark_mvcc(b *testing.B) {
-	mvcc.Create("test.db", "")
-	name := "file:/test.db?vfs=mvcc" +
-		"&_pragma=busy_timeout(10000)"
+	name := mvcc.TestDB(b, mvcc.Snapshot{}, url.Values{
+		"_pragma": {"busy_timeout(10000)"},
+	})
 	createDB(b, name)
 
 	b.ResetTimer()

tests/stmt_test.go

@@ -496,7 +496,7 @@ func TestStmt(t *testing.T) {
 		if got := stmt.ColumnBlob(0, nil); string(got) != "true" {
 			t.Errorf("got %q, want true", got)
 		}
-		var got any = 1
+		var got any
 		if err := stmt.ColumnJSON(0, &got); err != nil {
 			t.Error(err)
 		} else if got != true {

tests/time_test.go

@@ -1,7 +1,6 @@
 package tests
 
 import (
-	"context"
 	"fmt"
 	"reflect"
 	"testing"
@@ -134,37 +133,36 @@ func TestTimeFormat_Decode(t *testing.T) {
 
 func TestTimeFormat_Scanner(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	db, err := driver.Open(tmp)
+	db, err := driver.Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db.Close()
 
-	conn, err := db.Conn(ctx)
+	conn, err := db.Conn(t.Context())
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer conn.Close()
 
-	_, err = conn.ExecContext(ctx, `CREATE TABLE test (col)`)
+	_, err = conn.ExecContext(t.Context(), `CREATE TABLE test (col)`)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	reference := time.Date(2013, 10, 7, 4, 23, 19, 120_000_000, time.FixedZone("", -4*3600))
 
-	_, err = conn.ExecContext(ctx, `INSERT INTO test VALUES (?)`, sqlite3.TimeFormat7TZ.Encode(reference))
+	_, err = conn.ExecContext(t.Context(), `INSERT INTO test VALUES (?)`,
+		sqlite3.TimeFormat7TZ.Encode(reference))
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	var got time.Time
-	err = conn.QueryRowContext(ctx, "SELECT * FROM test").Scan(sqlite3.TimeFormatAuto.Scanner(&got))
+	err = conn.QueryRowContext(t.Context(), "SELECT * FROM test").
+		Scan(sqlite3.TimeFormatAuto.Scanner(&got))
 	if err != nil {
 		t.Fatal(err)
 	}

tests/txn_test.go

@@ -170,7 +170,7 @@ func TestConn_Transaction_interrupt(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx, cancel := context.WithCancel(t.Context())
 	db.SetInterrupt(ctx)
 
 	tx, err = db.BeginExclusive()
@@ -203,7 +203,7 @@ func TestConn_Transaction_interrupt(t *testing.T) {
 		t.Errorf("got %v, want sqlite3.INTERRUPT", err)
 	}
 
-	db.SetInterrupt(context.Background())
+	db.SetInterrupt(t.Context())
 	stmt, _, err := db.Prepare(`SELECT count(*) FROM test`)
 	if err != nil {
 		t.Fatal(err)
@@ -226,7 +226,7 @@ func TestConn_Transaction_interrupted(t *testing.T) {
 	}
 	defer db.Close()
 
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx, cancel := context.WithCancel(t.Context())
 	db.SetInterrupt(ctx)
 	cancel()
 
@@ -246,15 +246,15 @@ func TestConn_Transaction_interrupted(t *testing.T) {
 
 func TestConn_Transaction_busy(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db1, err := sqlite3.Open(tmp)
+	db1, err := sqlite3.Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db1.Close()
 
-	db2, err := sqlite3.Open(tmp + "&_pragma=busy_timeout(10000)")
+	db2, err := sqlite3.Open(dsn + "&_pragma=busy_timeout(10000)")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -274,7 +274,7 @@ func TestConn_Transaction_busy(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx, cancel := context.WithCancel(t.Context())
 	db2.SetInterrupt(ctx)
 	go cancel()
 
@@ -493,7 +493,7 @@ func TestConn_Savepoint_interrupt(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx, cancel := context.WithCancel(t.Context())
 	db.SetInterrupt(ctx)
 
 	savept1 := db.Savepoint()
@@ -530,7 +530,7 @@ func TestConn_Savepoint_interrupt(t *testing.T) {
 		t.Errorf("got %v, want sqlite3.INTERRUPT", err)
 	}
 
-	db.SetInterrupt(context.Background())
+	db.SetInterrupt(t.Context())
 	stmt, _, err := db.Prepare(`SELECT count(*) FROM test`)
 	if err != nil {
 		t.Fatal(err)

time.go

@@ -94,7 +94,7 @@ func (f TimeFormat) Encode(t time.Time) any {
 	case TimeFormatUnix:
 		return t.Unix()
 	case TimeFormatUnixFrac:
-		return float64(t.Unix()) + float64(t.Nanosecond())*1e-9
+		return math.FMA(1e-9, float64(t.Nanosecond()), float64(t.Unix()))
 	case TimeFormatUnixMilli:
 		return t.UnixMilli()
 	case TimeFormatUnixMicro:

util/sql3util/wasm/build.sh

@@ -24,8 +24,9 @@ trap 'rm -f sql3parse_table.tmp' EXIT
 	-Wl,--export=sql3parse_table
 
 "$BINARYEN/wasm-ctor-eval" -c _initialize sql3parse_table.wasm -o sql3parse_table.tmp
-"$BINARYEN/wasm-opt" --strip --strip-debug --strip-producers -c -Oz \
-	sql3parse_table.tmp -o sql3parse_table.wasm --low-memory-unused \
+"$BINARYEN/wasm-opt" sql3parse_table.tmp -o sql3parse_table.wasm \
+	--low-memory-unused --gufa --generate-global-effects --converge -Oz \
 	--enable-mutable-globals --enable-nontrapping-float-to-int \
 	--enable-simd --enable-bulk-memory --enable-sign-ext \
-	--enable-reference-types --enable-multivalue
+	--enable-reference-types --enable-multivalue \
+	--strip --strip-debug --strip-producers

value.go

@@ -1,9 +1,7 @@
 package sqlite3
 
 import (
-	"encoding/json"
 	"math"
-	"strconv"
 	"time"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
@@ -162,27 +160,6 @@ func (v Value) Pointer() any {
 	return util.GetHandle(v.c.ctx, ptr)
 }
 
-// JSON parses a JSON-encoded value
-// and stores the result in the value pointed to by ptr.
-func (v Value) JSON(ptr any) error {
-	var data []byte
-	switch v.Type() {
-	case NULL:
-		data = []byte("null")
-	case TEXT:
-		data = v.RawText()
-	case BLOB:
-		data = v.RawBlob()
-	case INTEGER:
-		data = strconv.AppendInt(nil, v.Int64(), 10)
-	case FLOAT:
-		data = util.AppendNumber(nil, v.Float())
-	default:
-		panic(util.AssertErr())
-	}
-	return json.Unmarshal(data, ptr)
-}
-
 // NoChange returns true if and only if the value is unchanged
 // in a virtual table update operatiom.
 //

vfs/adiantum/adiantum.go

@@ -25,8 +25,8 @@ func (adiantumCreator) HBSH(key []byte) *hbsh.HBSH {
 func (adiantumCreator) KDF(text string) []byte {
 	if text == "" {
 		key := make([]byte, 32)
-		n, _ := rand.Read(key)
-		return key[:n]
+		rand.Read(key)
+		return key
 	}
 	return argon2.IDKey([]byte(text), []byte(pepper), 3, 64*1024, 4, 32)
 }

vfs/adiantum/adiantum_test.go

@@ -54,9 +54,8 @@ func Test_fileformat(t *testing.T) {
 func Benchmark_nokey(b *testing.B) {
 	tmp := filepath.Join(b.TempDir(), "test.db")
 	sqlite3.Initialize()
-	b.ResetTimer()
 
-	for range b.N {
+	for b.Loop() {
 		db, err := sqlite3.Open("file:" + filepath.ToSlash(tmp) + "?nolock=1")
 		if err != nil {
 			b.Fatal(err)
@@ -68,9 +67,8 @@ func Benchmark_nokey(b *testing.B) {
 func Benchmark_hexkey(b *testing.B) {
 	tmp := filepath.Join(b.TempDir(), "test.db")
 	sqlite3.Initialize()
-	b.ResetTimer()
 
-	for range b.N {
+	for b.Loop() {
 		db, err := sqlite3.Open("file:" + filepath.ToSlash(tmp) + "?nolock=1" +
 			"&vfs=adiantum&hexkey=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
 		if err != nil {
@@ -83,9 +81,8 @@ func Benchmark_hexkey(b *testing.B) {
 func Benchmark_textkey(b *testing.B) {
 	tmp := filepath.Join(b.TempDir(), "test.db")
 	sqlite3.Initialize()
-	b.ResetTimer()
 
-	for range b.N {
+	for b.Loop() {
 		db, err := sqlite3.Open("file:" + filepath.ToSlash(tmp) + "?nolock=1" +
 			"&vfs=adiantum&textkey=correct+horse+battery+staple")
 		if err != nil {

vfs/adiantum/example_test.go

@@ -45,8 +45,8 @@ func (hpolycCreator) KDF(secret string) []byte {
 	if secret == "" {
 		// No secret is given, generate a random key.
 		key := make([]byte, 32)
-		n, _ := rand.Read(key)
-		return key[:n]
+		rand.Read(key)
+		return key
 	}
 	// Hash the secret with a KDF.
 	return argon2.IDKey([]byte(secret), []byte("hpolyc"), 3, 64*1024, 4, 32)

vfs/const.go

@@ -94,6 +94,10 @@ const (
 	OPEN_PRIVATECACHE  OpenFlag = 0x00040000 /* Ok for sqlite3_open_v2() */
 	OPEN_WAL           OpenFlag = 0x00080000 /* VFS only */
 	OPEN_NOFOLLOW      OpenFlag = 0x01000000 /* Ok for sqlite3_open_v2() */
+	_FLAG_ATOMIC       OpenFlag = 0x10000000
+	_FLAG_KEEP_WAL     OpenFlag = 0x20000000
+	_FLAG_PSOW         OpenFlag = 0x40000000
+	_FLAG_SYNC_DIR     OpenFlag = 0x80000000
 )
 
 // AccessFlag is a flag for the [VFS] Access method.

vfs/file.go

@@ -51,7 +51,7 @@ func (vfsOS) Delete(path string, syncDir bool) error {
 			return _OK
 		}
 		defer f.Close()
-		err = osSync(f, false, false)
+		err = osSync(f, 0, SYNC_FULL)
 		if err != nil {
 			return _IOERR_DIR_FSYNC
 		}
@@ -131,27 +131,24 @@ func (vfsOS) OpenFilename(name *Filename, flags OpenFlag) (File, OpenFlag, error
 	}
 
 	file := vfsFile{
-		File:     f,
-		psow:     true,
-		atomic:   osBatchAtomic(f),
-		readOnly: flags&OPEN_READONLY != 0,
-		syncDir:  isUnix && isCreate && isJournl,
-		delete:   !isUnix && flags&OPEN_DELETEONCLOSE != 0,
-		shm:      NewSharedMemory(name.String()+"-shm", flags),
+		File:  f,
+		flags: flags | _FLAG_PSOW,
+		shm:   NewSharedMemory(name.String()+"-shm", flags),
+	}
+	if osBatchAtomic(f) {
+		file.flags |= _FLAG_ATOMIC
+	}
+	if isUnix && isCreate && isJournl {
+		file.flags |= _FLAG_SYNC_DIR
 	}
 	return &file, flags, nil
 }
 
 type vfsFile struct {
 	*os.File
-	shm      SharedMemory
-	lock     LockLevel
-	readOnly bool
-	keepWAL  bool
-	syncDir  bool
-	atomic   bool
-	delete   bool
-	psow     bool
+	shm   SharedMemory
+	lock  LockLevel
+	flags OpenFlag
 }
 
 var (
@@ -164,7 +161,7 @@ var (
 )
 
 func (f *vfsFile) Close() error {
-	if f.delete {
+	if !isUnix && f.flags&OPEN_DELETEONCLOSE != 0 {
 		defer os.Remove(f.Name())
 	}
 	if f.shm != nil {
@@ -183,21 +180,18 @@ func (f *vfsFile) WriteAt(p []byte, off int64) (n int, err error) {
 }
 
 func (f *vfsFile) Sync(flags SyncFlag) error {
-	dataonly := (flags & SYNC_DATAONLY) != 0
-	fullsync := (flags & 0x0f) == SYNC_FULL
-
-	err := osSync(f.File, fullsync, dataonly)
+	err := osSync(f.File, f.flags, flags)
 	if err != nil {
 		return err
 	}
-	if isUnix && f.syncDir {
-		f.syncDir = false
+	if isUnix && f.flags&_FLAG_SYNC_DIR != 0 {
+		f.flags ^= _FLAG_SYNC_DIR
 		d, err := os.Open(filepath.Dir(f.File.Name()))
 		if err != nil {
 			return nil
 		}
 		defer d.Close()
-		err = osSync(d, false, false)
+		err = osSync(f.File, f.flags, flags)
 		if err != nil {
 			return _IOERR_DIR_FSYNC
 		}
@@ -215,10 +209,10 @@ func (f *vfsFile) SectorSize() int {
 
 func (f *vfsFile) DeviceCharacteristics() DeviceCharacteristic {
 	ret := IOCAP_SUBPAGE_READ
-	if f.atomic {
+	if f.flags&_FLAG_ATOMIC != 0 {
 		ret |= IOCAP_BATCH_ATOMIC
 	}
-	if f.psow {
+	if f.flags&_FLAG_PSOW != 0 {
 		ret |= IOCAP_POWERSAFE_OVERWRITE
 	}
 	if runtime.GOOS == "windows" {
@@ -249,8 +243,20 @@ func (f *vfsFile) HasMoved() (bool, error) {
 	return !os.SameFile(fi, pi), nil
 }
 
-func (f *vfsFile) LockState() LockLevel            { return f.lock }
-func (f *vfsFile) PowersafeOverwrite() bool        { return f.psow }
-func (f *vfsFile) PersistWAL() bool                { return f.keepWAL }
-func (f *vfsFile) SetPowersafeOverwrite(psow bool) { f.psow = psow }
-func (f *vfsFile) SetPersistWAL(keepWAL bool)      { f.keepWAL = keepWAL }
+func (f *vfsFile) LockState() LockLevel     { return f.lock }
+func (f *vfsFile) PowersafeOverwrite() bool { return f.flags&_FLAG_PSOW != 0 }
+func (f *vfsFile) PersistWAL() bool         { return f.flags&_FLAG_KEEP_WAL != 0 }
+
+func (f *vfsFile) SetPowersafeOverwrite(psow bool) {
+	f.flags &^= _FLAG_PSOW
+	if psow {
+		f.flags |= _FLAG_PSOW
+	}
+}
+
+func (f *vfsFile) SetPersistWAL(keepWAL bool) {
+	f.flags &^= _FLAG_KEEP_WAL
+	if keepWAL {
+		f.flags |= _FLAG_KEEP_WAL
+	}
+}

vfs/lock.go

@@ -41,7 +41,7 @@ func (f *vfsFile) Lock(lock LockLevel) error {
 	}
 
 	// Do not allow any kind of write-lock on a read-only database.
-	if f.readOnly && lock >= LOCK_RESERVED {
+	if lock >= LOCK_RESERVED && f.flags&OPEN_READONLY != 0 {
 		return _IOERR_LOCK
 	}
 

vfs/memdb/README.md

@@ -6,4 +6,7 @@ SQLite VFS in pure Go.
 It has some benefits over the C version:
 - the memory backing the database needs not be contiguous,
 - the database can grow/shrink incrementally without copying,
-- reader-writer concurrency is slightly improved.
+- reader-writer concurrency is slightly improved.
+
+[`memdb.TestDB`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/memdb#TestDB)
+is the preferred way to setup an in-memory database for testing.

vfs/memdb/api.go

@@ -10,6 +10,7 @@
 package memdb
 
 import (
+	"crypto/rand"
 	"fmt"
 	"net/url"
 	"sync"
@@ -74,11 +75,27 @@ func Delete(name string) {
 
 // TestDB creates an empty shared memory database for the test to use.
 // The database is automatically deleted when the test and all its subtests complete.
+// Returns a URI filename appropriate to call Open with.
 // Each subsequent call to TestDB returns a unique database.
+//
+//	func Test_something(t *testing.T) {
+//		t.Parallel()
+//		dsn := memdb.TestDB(t, url.Values{
+//			"_pragma": {"busy_timeout(1000)"},
+//		})
+//
+//		db, err := sql.Open("sqlite3", dsn)
+//		if err != nil {
+//			t.Fatal(err)
+//		}
+//		defer db.Close()
+//
+//		// ...
+//	}
 func TestDB(tb testing.TB, params ...url.Values) string {
 	tb.Helper()
 
-	name := fmt.Sprintf("%s_%p", tb.Name(), tb)
+	name := fmt.Sprintf("%s_%s", tb.Name(), rand.Text())
 	tb.Cleanup(func() { Delete(name) })
 	Create(name, nil)
 

vfs/mvcc/README.md

@@ -3,7 +3,13 @@
 This package implements the **EXPERIMENTAL** `"mvcc"` in-memory SQLite VFS.
 
 It has some benefits over the [`"memdb"`](../memdb/README.md) VFS:
-- panics do not corrupt a shared database;
+- panics do not corrupt a shared database,
 - single-writer not blocked by readers,
 - readers never block,
-- instant snapshots.
+- instant snapshots.
+
+[`mvcc.TestDB`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/mvcc#TestDB)
+is the preferred way to setup an in-memory database for testing
+when you intend to leverage snapshots,
+e.g. to setup many independent copies of a database,
+such as one for each subtest.

vfs/mvcc/api.go

@@ -10,9 +10,15 @@
 package mvcc
 
 import (
+	"crypto/rand"
+	"fmt"
+	"net/url"
+	"strings"
 	"sync"
+	"testing"
 
 	"github.com/ncruces/go-sqlite3/vfs"
+	"github.com/ncruces/wbt"
 )
 
 func init() {
@@ -26,42 +32,118 @@ var (
 )
 
 // Create creates a shared memory database,
-// using data as its initial contents.
-func Create(name string, data string) {
+// using a snapshot as its initial contents.
+func Create(name string, snapshot Snapshot) {
 	memoryMtx.Lock()
 	defer memoryMtx.Unlock()
 
-	db := &mvccDB{
+	memoryDBs[name] = &mvccDB{
 		refs: 1,
 		name: name,
-	}
-	memoryDBs[name] = db
-	if len(data) == 0 {
-		return
-	}
-	// Convert data from WAL/2 to rollback journal.
-	if len(data) >= 20 && (false ||
-		data[18] == 2 && data[19] == 2 ||
-		data[18] == 3 && data[19] == 3) {
-		db.data = db.data.
-			Put(0, data[:18]).
-			Put(18, "\001\001").
-			Put(20, data[20:])
-	} else {
-		db.data = db.data.Put(0, data)
+		data: snapshot.Tree,
 	}
 }
 
 // Delete deletes a shared memory database.
 func Delete(name string) {
+	name = getName(name)
+
 	memoryMtx.Lock()
 	defer memoryMtx.Unlock()
 	delete(memoryDBs, name)
 }
 
-// Snapshot stores a snapshot of database src into dst.
-func Snapshot(dst, src string) {
+// Snapshot represents a database snapshot.
+type Snapshot struct {
+	*wbt.Tree[int64, string]
+}
+
+// NewSnapshot creates a snapshot from data.
+func NewSnapshot(data string) Snapshot {
+	var tree *wbt.Tree[int64, string]
+
+	// Convert data from WAL/2 to rollback journal.
+	if len(data) >= 20 && (false ||
+		data[18] == 2 && data[19] == 2 ||
+		data[18] == 3 && data[19] == 3) {
+		tree = tree.
+			Put(0, data[:18]).
+			Put(18, "\001\001").
+			Put(20, data[20:])
+	} else if len(data) > 0 {
+		tree = tree.Put(0, data)
+	}
+
+	return Snapshot{tree}
+}
+
+// TakeSnapshot takes a snapshot of a database.
+// Name may be a URI filename.
+func TakeSnapshot(name string) Snapshot {
+	name = getName(name)
+
 	memoryMtx.Lock()
 	defer memoryMtx.Unlock()
-	memoryDBs[dst] = memoryDBs[src].fork()
+	db := memoryDBs[name]
+	if db == nil {
+		return Snapshot{}
+	}
+
+	db.mtx.Lock()
+	defer db.mtx.Unlock()
+	return Snapshot{db.data}
+}
+
+// TestDB creates a shared database from a snapshot for the test to use.
+// The database is automatically deleted when the test and all its subtests complete.
+// Returns a URI filename appropriate to call Open with.
+// Each subsequent call to TestDB returns a unique database.
+//
+//	func Test_something(t *testing.T) {
+//		t.Parallel()
+//		dsn := mvcc.TestDB(t, snapshot, url.Values{
+//			"_pragma": {"busy_timeout(1000)"},
+//		})
+//
+//		db, err := sql.Open("sqlite3", dsn)
+//		if err != nil {
+//			t.Fatal(err)
+//		}
+//		defer db.Close()
+//
+//		// ...
+//	}
+func TestDB(tb testing.TB, snapshot Snapshot, params ...url.Values) string {
+	tb.Helper()
+
+	name := fmt.Sprintf("%s_%s", tb.Name(), rand.Text())
+	tb.Cleanup(func() { Delete(name) })
+	Create(name, snapshot)
+
+	p := url.Values{"vfs": {"mvcc"}}
+	for _, v := range params {
+		for k, v := range v {
+			for _, v := range v {
+				p.Add(k, v)
+			}
+		}
+	}
+
+	return (&url.URL{
+		Scheme:   "file",
+		OmitHost: true,
+		Path:     "/" + name,
+		RawQuery: p.Encode(),
+	}).String()
+}
+
+func getName(dsn string) string {
+	u, err := url.Parse(dsn)
+	if err == nil &&
+		u.Scheme == "file" &&
+		strings.HasPrefix(u.Path, "/") &&
+		u.Query().Get("vfs") == "mvcc" {
+		return u.Path[1:]
+	}
+	return dsn
 }

vfs/mvcc/example_test.go

@@ -15,7 +15,7 @@ import (
 var testDB string
 
 func Example() {
-	mvcc.Create("test.db", testDB)
+	mvcc.Create("test.db", mvcc.NewSnapshot(testDB))
 
 	db, err := sql.Open("sqlite3", "file:/test.db?vfs=mvcc")
 	if err != nil {

vfs/mvcc/mvcc.go

@@ -6,10 +6,10 @@ import (
 	"sync"
 	"time"
 
-	"github.com/ncruces/aa"
 	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/util/vfsutil"
 	"github.com/ncruces/go-sqlite3/vfs"
+	"github.com/ncruces/wbt"
 )
 
 type mvccVFS struct{}
@@ -68,9 +68,9 @@ func (mvccVFS) FullPathname(name string) (string, error) {
 }
 
 type mvccDB struct {
-	data   *aa.Tree[int64, string] // +checklocks:mtx
-	owner  *mvccFile               // +checklocks:mtx
-	waiter *sync.Cond              // +checklocks:mtx
+	data   *wbt.Tree[int64, string] // +checklocks:mtx
+	owner  *mvccFile                // +checklocks:mtx
+	waiter *sync.Cond               // +checklocks:mtx
 
 	name string
 	refs int // +checklocks:memoryMtx
@@ -85,19 +85,9 @@ func (m *mvccDB) release() {
 	}
 }
 
-func (m *mvccDB) fork() *mvccDB {
-	m.mtx.Lock()
-	defer m.mtx.Unlock()
-	return &mvccDB{
-		refs: 1,
-		name: m.name,
-		data: m.data,
-	}
-}
-
 type mvccFile struct {
 	*mvccDB
-	data     *aa.Tree[int64, string]
+	data     *wbt.Tree[int64, string]
 	lock     vfs.LockLevel
 	readOnly bool
 }

vfs/mvcc/mvcc_test.go

@@ -14,10 +14,9 @@ var walDB string
 
 func Test_wal(t *testing.T) {
 	t.Parallel()
+	dsn := TestDB(t, NewSnapshot(walDB))
 
-	Create("test.db", walDB)
-
-	db, err := sqlite3.Open("file:/test.db?vfs=mvcc")
+	db, err := sqlite3.Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}

vfs/os_darwin.go

@@ -23,12 +23,26 @@ type flocktimeout_t struct {
 	timeout unix.Timespec
 }
 
-func osSync(file *os.File, fullsync, _ /*dataonly*/ bool) error {
-	if fullsync {
-		return file.Sync()
+func osSync(file *os.File, open OpenFlag, sync SyncFlag) error {
+	var cmd int
+	if sync&SYNC_FULL == SYNC_FULL {
+		// For rollback journals all we really need is a barrier.
+		if open&OPEN_MAIN_JOURNAL != 0 {
+			cmd = unix.F_BARRIERFSYNC
+		} else {
+			cmd = unix.F_FULLFSYNC
+		}
 	}
+
+	fd := file.Fd()
 	for {
-		err := unix.Fsync(int(file.Fd()))
+		err := error(unix.ENOTSUP)
+		if cmd != 0 {
+			_, err = unix.FcntlInt(fd, cmd, 0)
+		}
+		if err == unix.ENOTSUP {
+			err = unix.Fsync(int(fd))
+		}
 		if err != unix.EINTR {
 			return err
 		}

vfs/os_linux.go

@@ -10,7 +10,7 @@ import (
 	"golang.org/x/sys/unix"
 )
 
-func osSync(file *os.File, _ /*fullsync*/, _ /*dataonly*/ bool) error {
+func osSync(file *os.File, _ OpenFlag, _ SyncFlag) error {
 	// SQLite trusts Linux's fdatasync for all fsync's.
 	for {
 		err := unix.Fdatasync(int(file.Fd()))

vfs/os_std_sync.go

@@ -4,6 +4,6 @@ package vfs
 
 import "os"
 
-func osSync(file *os.File, _ /*fullsync*/, _ /*dataonly*/ bool) error {
+func osSync(file *os.File, _ OpenFlag, _ SyncFlag) error {
 	return file.Sync()
 }

vfs/tests/mptest/mptest_test.go

@@ -197,7 +197,7 @@ func Test_multiwrite01_memory(t *testing.T) {
 }
 
 func Test_config01_mvcc(t *testing.T) {
-	mvcc.Create("test.db", "")
+	mvcc.Create("test.db", mvcc.Snapshot{})
 	ctx := util.NewContext(newContext(t))
 	cfg := config(ctx).WithArgs("mptest", "/test.db", "config01.test",
 		"--vfs", "mvcc")
@@ -213,7 +213,7 @@ func Test_crash01_mvcc(t *testing.T) {
 		t.Skip("skipping in short mode")
 	}
 
-	mvcc.Create("test.db", "")
+	mvcc.Create("test.db", mvcc.Snapshot{})
 	ctx := util.NewContext(newContext(t))
 	cfg := config(ctx).WithArgs("mptest", "/test.db", "crash01.test",
 		"--vfs", "mvcc")
@@ -229,7 +229,7 @@ func Test_multiwrite01_mvcc(t *testing.T) {
 		t.Skip("skipping in slow CI")
 	}
 
-	mvcc.Create("test.db", "")
+	mvcc.Create("test.db", mvcc.Snapshot{})
 	ctx := util.NewContext(newContext(t))
 	cfg := config(ctx).WithArgs("mptest", "/test.db", "multiwrite01.test",
 		"--vfs", "mvcc")
@@ -371,7 +371,7 @@ func Test_crash01_xts_wal(t *testing.T) {
 }
 
 func newContext(t *testing.T) context.Context {
-	return context.WithValue(context.Background(), logger{}, &testWriter{T: t})
+	return context.WithValue(t.Context(), logger{}, &testWriter{T: t})
 }
 
 type logger struct{}

vfs/tests/mptest/wasm/build.sh

@@ -26,9 +26,10 @@ WASI_SDK="$ROOT/tools/wasi-sdk/bin"
 	-D_WASI_EMULATED_GETPID -lwasi-emulated-getpid \
 	$(awk '{print "-Wl,--export="$0}' exports.txt)
 
-"$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
-	mptest.wasm -o mptest.tmp --low-memory-unused \
+"$BINARYEN/wasm-opt" -g mptest.wasm -o mptest.tmp \
+	--low-memory-unused --gufa --generate-global-effects --converge -O3 \
 	--enable-mutable-globals --enable-nontrapping-float-to-int \
 	--enable-simd --enable-bulk-memory --enable-sign-ext \
-	--enable-reference-types --enable-multivalue
+	--enable-reference-types --enable-multivalue \
+	--strip --strip-producers
 mv mptest.tmp mptest.wasm

vfs/tests/speedtest1/speedtest1_test.go

@@ -82,7 +82,7 @@ func initFlags() {
 
 func Benchmark_speedtest1(b *testing.B) {
 	output.Reset()
-	ctx := util.NewContext(context.Background())
+	ctx := util.NewContext(b.Context())
 	name := filepath.Join(b.TempDir(), "test.db")
 	args := append(options, "--size", strconv.Itoa(b.N), name)
 	cfg := wazero.NewModuleConfig().
@@ -100,7 +100,7 @@ func Benchmark_speedtest1(b *testing.B) {
 
 func Benchmark_adiantum(b *testing.B) {
 	output.Reset()
-	ctx := util.NewContext(context.Background())
+	ctx := util.NewContext(b.Context())
 	name := "file:" + filepath.Join(b.TempDir(), "test.db") +
 		"?hexkey=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
 	args := append(options, "--vfs", "adiantum", "--size", strconv.Itoa(b.N), name)
@@ -119,7 +119,7 @@ func Benchmark_adiantum(b *testing.B) {
 
 func Benchmark_xts(b *testing.B) {
 	output.Reset()
-	ctx := util.NewContext(context.Background())
+	ctx := util.NewContext(b.Context())
 	name := "file:" + filepath.Join(b.TempDir(), "test.db") +
 		"?hexkey=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
 	args := append(options, "--vfs", "xts", "--size", strconv.Itoa(b.N), name)

vfs/tests/speedtest1/wasm/build.sh

@@ -21,9 +21,10 @@ WASI_SDK="$ROOT/tools/wasi-sdk/bin"
 	-DSQLITE_CUSTOM_INCLUDE=sqlite_opt.h \
 	$(awk '{print "-Wl,--export="$0}' exports.txt)
 
-"$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
-	speedtest1.wasm -o speedtest1.tmp --low-memory-unused \
+"$BINARYEN/wasm-opt" -g speedtest1.wasm -o speedtest1.tmp \
+	--low-memory-unused --gufa --generate-global-effects --converge -O3 \
 	--enable-mutable-globals --enable-nontrapping-float-to-int \
 	--enable-simd --enable-bulk-memory --enable-sign-ext \
-	--enable-reference-types --enable-multivalue
+	--enable-reference-types --enable-multivalue \
+	--strip --strip-producers
 mv speedtest1.tmp speedtest1.wasm

vfs/xts/README.md

@@ -9,12 +9,12 @@ In general, any XTS construction can be used to wrap any VFS.
 
 The default AES-XTS construction uses AES-128, AES-192, or AES-256
 for its block cipher.
-Additionally, we use [PBKDF2-HMAC-SHA512](https://pkg.go.dev/golang.org/x/crypto/pbkdf2)
+Additionally, we use [PBKDF2-HMAC-SHA512](https://pkg.go.dev/crypto/pbkdf2)
 to derive AES-128 keys from plain text where needed.
 File contents are encrypted in 512 byte sectors, matching the
 [minimum](https://sqlite.org/fileformat.html#pages) SQLite page size.
 
-This VFS uses _only_ NIST and FIPS 140-2 approved cryptographic primitives,
+This VFS uses _only_ NIST and FIPS 140-3 approved cryptographic primitives,
 which _may_ help you become FIPS compliant.
 
 The VFS encrypts all files _except_

vfs/xts/aes.go

@@ -2,10 +2,10 @@ package xts
 
 import (
 	"crypto/aes"
+	"crypto/pbkdf2"
 	"crypto/rand"
 	"crypto/sha512"
 
-	"golang.org/x/crypto/pbkdf2"
 	"golang.org/x/crypto/xts"
 )
 
@@ -27,8 +27,12 @@ func (aesCreator) XTS(key []byte) *xts.Cipher {
 func (aesCreator) KDF(text string) []byte {
 	if text == "" {
 		key := make([]byte, 32)
-		n, _ := rand.Read(key)
-		return key[:n]
+		rand.Read(key)
+		return key
 	}
-	return pbkdf2.Key([]byte(text), []byte(pepper), 10_000, 32, sha512.New)
+	key, err := pbkdf2.Key(sha512.New, text, []byte(pepper), 10_000, 32)
+	if err != nil {
+		panic(err)
+	}
+	return key
 }

vfs/xts/aes_test.go

@@ -54,9 +54,8 @@ func Test_fileformat(t *testing.T) {
 func Benchmark_nokey(b *testing.B) {
 	tmp := filepath.Join(b.TempDir(), "test.db")
 	sqlite3.Initialize()
-	b.ResetTimer()
 
-	for range b.N {
+	for b.Loop() {
 		db, err := sqlite3.Open("file:" + filepath.ToSlash(tmp) + "?nolock=1")
 		if err != nil {
 			b.Fatal(err)
@@ -68,9 +67,8 @@ func Benchmark_nokey(b *testing.B) {
 func Benchmark_hexkey(b *testing.B) {
 	tmp := filepath.Join(b.TempDir(), "test.db")
 	sqlite3.Initialize()
-	b.ResetTimer()
 
-	for range b.N {
+	for b.Loop() {
 		db, err := sqlite3.Open("file:" + filepath.ToSlash(tmp) + "?nolock=1" +
 			"&vfs=xts&hexkey=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
 		if err != nil {
@@ -83,9 +81,8 @@ func Benchmark_hexkey(b *testing.B) {
 func Benchmark_textkey(b *testing.B) {
 	tmp := filepath.Join(b.TempDir(), "test.db")
 	sqlite3.Initialize()
-	b.ResetTimer()
 
-	for range b.N {
+	for b.Loop() {
 		db, err := sqlite3.Open("file:" + filepath.ToSlash(tmp) + "?nolock=1" +
 			"&vfs=xts&textkey=correct+horse+battery+staple")
 		if err != nil {