Tests.

Bumps [golang.org/x/sys](https://github.com/golang/sys) from 0.5.0 to 0.6.0.
- [Release notes](https://github.com/golang/sys/releases)
- [Commits](https://github.com/golang/sys/compare/v0.5.0...v0.6.0)

---
updated-dependencies:
- dependency-name: golang.org/x/sys
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/workflows/go.yml

@@ -15,6 +15,8 @@ jobs:
 
     steps:
     - uses: actions/checkout@v3
+      with:
+        lfs: 'true'
 
     - name: Set up Go
       uses: actions/setup-go@v3

.gitignore

@@ -13,7 +13,4 @@
 
 # Dependency directories (remove the comment below to include it)
 # vendor/
-tools
-
-# Project
-sqlite3/sqlite3*
+tools

README.md

@@ -2,7 +2,7 @@
 
 [![Go Reference](https://pkg.go.dev/badge/image)](https://pkg.go.dev/github.com/ncruces/go-sqlite3)
 [![Go Report](https://goreportcard.com/badge/github.com/ncruces/go-sqlite3)](https://goreportcard.com/report/github.com/ncruces/go-sqlite3)
-[![Go Coverage](https://github.com/ncruces/go-sqlite3/wiki/coverage.svg)](https://raw.githack.com/wiki/ncruces/go-sqlite3/coverage.html)
+[![Go Coverage](https://github.com/ncruces/go-sqlite3/wiki/coverage.svg)](https://github.com/ncruces/go-sqlite3/wiki/Test-coverage-report)
 
 Go module `github.com/ncruces/go-sqlite3` wraps a [WASM](https://webassembly.org/) build of [SQLite](https://sqlite.org/),
 and uses [wazero](https://wazero.io/) to provide `cgo`-free SQLite bindings.
@@ -55,11 +55,11 @@ As a work around for other Unixes, you can use [`nolock=1`](https://www.sqlite.o
 - [ ] advanced SQLite features
   - [x] nested transactions
   - [x] incremental BLOB I/O
-  - [ ] online backup
+  - [x] online backup
   - [ ] snapshots
   - [ ] session extension
   - [ ] resumable bulk update
-  - [ ] shared cache mode
+  - [ ] shared-cache mode
   - [ ] unlock-notify
 - [ ] custom SQL functions
 - [ ] custom VFSes

api.go

@@ -1,126 +0,0 @@
-// Package sqlite3 wraps the C SQLite API.
-package sqlite3
-
-import (
-	"context"
-
-	"github.com/tetratelabs/wazero/api"
-)
-
-func newConn(ctx context.Context, module api.Module) (_ *Conn, err error) {
-	getFun := func(name string) api.Function {
-		f := module.ExportedFunction(name)
-		if f == nil {
-			err = noFuncErr + errorString(name)
-			return nil
-		}
-		return f
-	}
-
-	getVal := func(name string) uint32 {
-		global := module.ExportedGlobal(name)
-		if global == nil {
-			err = noGlobalErr + errorString(name)
-			return 0
-		}
-		return memory{module}.readUint32(uint32(global.Get()))
-	}
-
-	c := Conn{
-		ctx: ctx,
-		mem: memory{module},
-		api: sqliteAPI{
-			free:          getFun("free"),
-			malloc:        getFun("malloc"),
-			destructor:    uint64(getVal("malloc_destructor")),
-			errcode:       getFun("sqlite3_errcode"),
-			errstr:        getFun("sqlite3_errstr"),
-			errmsg:        getFun("sqlite3_errmsg"),
-			erroff:        getFun("sqlite3_error_offset"),
-			open:          getFun("sqlite3_open_v2"),
-			close:         getFun("sqlite3_close"),
-			prepare:       getFun("sqlite3_prepare_v3"),
-			finalize:      getFun("sqlite3_finalize"),
-			reset:         getFun("sqlite3_reset"),
-			step:          getFun("sqlite3_step"),
-			exec:          getFun("sqlite3_exec"),
-			clearBindings: getFun("sqlite3_clear_bindings"),
-			bindCount:     getFun("sqlite3_bind_parameter_count"),
-			bindIndex:     getFun("sqlite3_bind_parameter_index"),
-			bindName:      getFun("sqlite3_bind_parameter_name"),
-			bindNull:      getFun("sqlite3_bind_null"),
-			bindInteger:   getFun("sqlite3_bind_int64"),
-			bindFloat:     getFun("sqlite3_bind_double"),
-			bindText:      getFun("sqlite3_bind_text64"),
-			bindBlob:      getFun("sqlite3_bind_blob64"),
-			bindZeroBlob:  getFun("sqlite3_bind_zeroblob64"),
-			columnCount:   getFun("sqlite3_column_count"),
-			columnName:    getFun("sqlite3_column_name"),
-			columnType:    getFun("sqlite3_column_type"),
-			columnInteger: getFun("sqlite3_column_int64"),
-			columnFloat:   getFun("sqlite3_column_double"),
-			columnText:    getFun("sqlite3_column_text"),
-			columnBlob:    getFun("sqlite3_column_blob"),
-			columnBytes:   getFun("sqlite3_column_bytes"),
-			autocommit:    getFun("sqlite3_get_autocommit"),
-			lastRowid:     getFun("sqlite3_last_insert_rowid"),
-			changes:       getFun("sqlite3_changes64"),
-			blobOpen:      getFun("sqlite3_blob_open"),
-			blobClose:     getFun("sqlite3_blob_close"),
-			blobReopen:    getFun("sqlite3_blob_reopen"),
-			blobBytes:     getFun("sqlite3_blob_bytes"),
-			blobRead:      getFun("sqlite3_blob_read"),
-			blobWrite:     getFun("sqlite3_blob_write"),
-			interrupt:     getVal("sqlite3_interrupt_offset"),
-		},
-	}
-	if err != nil {
-		return nil, err
-	}
-	return &c, nil
-}
-
-type sqliteAPI struct {
-	free          api.Function
-	malloc        api.Function
-	destructor    uint64
-	errcode       api.Function
-	errstr        api.Function
-	errmsg        api.Function
-	erroff        api.Function
-	open          api.Function
-	close         api.Function
-	prepare       api.Function
-	finalize      api.Function
-	reset         api.Function
-	step          api.Function
-	exec          api.Function
-	clearBindings api.Function
-	bindNull      api.Function
-	bindCount     api.Function
-	bindIndex     api.Function
-	bindName      api.Function
-	bindInteger   api.Function
-	bindFloat     api.Function
-	bindText      api.Function
-	bindBlob      api.Function
-	bindZeroBlob  api.Function
-	columnCount   api.Function
-	columnName    api.Function
-	columnType    api.Function
-	columnInteger api.Function
-	columnFloat   api.Function
-	columnText    api.Function
-	columnBlob    api.Function
-	columnBytes   api.Function
-	autocommit    api.Function
-	lastRowid     api.Function
-	changes       api.Function
-	blobOpen      api.Function
-	blobClose     api.Function
-	blobReopen    api.Function
-	blobBytes     api.Function
-	blobRead      api.Function
-	blobWrite     api.Function
-	interrupt     uint32
-}

backup.go

@@ -0,0 +1,134 @@
+package sqlite3
+
+// Backup is a handle to an open BLOB.
+//
+// https://www.sqlite.org/c3ref/backup.html
+type Backup struct {
+	c      *Conn
+	handle uint32
+	otherc uint32
+}
+
+// Backup backs up srcDB on the src connection to the "main" database in dstURI.
+//
+// Backup calls [Conn.Open] to open the SQLite database file dstURI,
+// and blocks until the entire backup is complete.
+// Use [Conn.BackupInit] for incremental backup.
+//
+// https://www.sqlite.org/backup.html
+func (src *Conn) Backup(srcDB, dstURI string) error {
+	b, err := src.BackupInit(srcDB, dstURI)
+	if err != nil {
+		return err
+	}
+	defer b.Close()
+	_, err = b.Step(-1)
+	return err
+}
+
+// Restore restores dstDB on the dst connection from the "main" database in srcURI.
+//
+// Restore calls [Conn.Open] to open the SQLite database file srcURI,
+// and blocks until the entire restore is complete.
+//
+// https://www.sqlite.org/backup.html
+func (dst *Conn) Restore(dstDB, srcURI string) error {
+	src, err := dst.openDB(srcURI, OPEN_READWRITE|OPEN_CREATE|OPEN_URI)
+	if err != nil {
+		return err
+	}
+	b, err := dst.backupInit(dst.handle, dstDB, src, "main")
+	if err != nil {
+		return err
+	}
+	defer b.Close()
+	_, err = b.Step(-1)
+	return err
+}
+
+// BackupInit initializes a backup operation to copy the content of one database into another.
+//
+// BackupInit calls [Conn.Open] to open the SQLite database file dstURI,
+// then initializes a backup that copies the contents of srcDB on the src connection
+// to the "main" database in dstURI.
+//
+// https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupinit
+func (src *Conn) BackupInit(srcDB, dstURI string) (*Backup, error) {
+	dst, err := src.openDB(dstURI, OPEN_READWRITE|OPEN_CREATE|OPEN_URI)
+	if err != nil {
+		return nil, err
+	}
+	return src.backupInit(dst, "main", src.handle, srcDB)
+}
+
+func (c *Conn) backupInit(dst uint32, dstName string, src uint32, srcName string) (*Backup, error) {
+	defer c.arena.reset()
+	dstPtr := c.arena.string(dstName)
+	srcPtr := c.arena.string(srcName)
+
+	other := dst
+	if c.handle == dst {
+		other = src
+	}
+
+	r := c.call(c.api.backupInit,
+		uint64(dst), uint64(dstPtr),
+		uint64(src), uint64(srcPtr))
+	if r[0] == 0 {
+		defer c.closeDB(other)
+		r = c.call(c.api.errcode, uint64(dst))
+		return nil, c.module.error(r[0], dst)
+	}
+
+	return &Backup{
+		c:      c,
+		otherc: other,
+		handle: uint32(r[0]),
+	}, nil
+}
+
+// Close finishes a backup operation.
+//
+// It is safe to close a nil, zero or closed Backup.
+//
+// https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupfinish
+func (b *Backup) Close() error {
+	if b == nil || b.handle == 0 {
+		return nil
+	}
+
+	r := b.c.call(b.c.api.backupFinish, uint64(b.handle))
+	b.c.closeDB(b.otherc)
+	b.handle = 0
+	return b.c.error(r[0])
+}
+
+// Step copies up to nPage pages between the source and destination databases.
+// If nPage is negative, all remaining source pages are copied.
+//
+// https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupstep
+func (b *Backup) Step(nPage int) (done bool, err error) {
+	r := b.c.call(b.c.api.backupStep, uint64(b.handle), uint64(nPage))
+	if r[0] == _DONE {
+		return true, nil
+	}
+	return false, b.c.error(r[0])
+}
+
+// Remaining returns the number of pages still to be backed up
+// at the conclusion of the most recent [Backup.Step].
+//
+// https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupremaining
+func (b *Backup) Remaining() int {
+	r := b.c.call(b.c.api.backupRemaining, uint64(b.handle))
+	return int(r[0])
+}
+
+// PageCount returns the total number of pages in the source database
+// at the conclusion of the most recent [Backup.Step].
+//
+// https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backuppagecount
+func (b *Backup) PageCount() int {
+	r := b.c.call(b.c.api.backupFinish, uint64(b.handle))
+	return int(r[0])
+}

compile.go

@@ -1,68 +0,0 @@
-package sqlite3
-
-import (
-	"context"
-	"crypto/rand"
-	"os"
-	"runtime"
-	"strconv"
-	"sync"
-	"sync/atomic"
-
-	"github.com/tetratelabs/wazero"
-	"github.com/tetratelabs/wazero/api"
-)
-
-// Configure SQLite WASM.
-//
-// Importing package embed initializes these
-// with an appropriate build of SQLite:
-//
-//	import _ "github.com/ncruces/go-sqlite3/embed"
-var (
-	Binary []byte // WASM binary to load.
-	Path   string // Path to load the binary from.
-)
-
-var sqlite3 sqlite3Runtime
-
-type sqlite3Runtime struct {
-	once      sync.Once
-	runtime   wazero.Runtime
-	compiled  wazero.CompiledModule
-	instances atomic.Uint64
-	err       error
-}
-
-func (s *sqlite3Runtime) instantiateModule(ctx context.Context) (api.Module, error) {
-	s.once.Do(func() { s.compileModule(ctx) })
-	if s.err != nil {
-		return nil, s.err
-	}
-
-	cfg := wazero.NewModuleConfig().
-		WithName("sqlite3-" + strconv.FormatUint(s.instances.Add(1), 10)).
-		WithSysWalltime().WithSysNanotime().WithSysNanosleep().
-		WithOsyield(runtime.Gosched).
-		WithRandSource(rand.Reader)
-	return s.runtime.InstantiateModule(ctx, s.compiled, cfg)
-}
-
-func (s *sqlite3Runtime) compileModule(ctx context.Context) {
-	s.runtime = wazero.NewRuntime(ctx)
-	vfsInstantiate(ctx, s.runtime)
-
-	bin := Binary
-	if bin == nil && Path != "" {
-		bin, s.err = os.ReadFile(Path)
-		if s.err != nil {
-			return
-		}
-	}
-	if bin == nil {
-		s.err = binaryErr
-		return
-	}
-
-	s.compiled, s.err = s.runtime.CompileModule(ctx, bin)
-}

conn.go

@@ -4,13 +4,11 @@ import (
 	"context"
 	"database/sql/driver"
 	"fmt"
-	"math"
 	"net/url"
+	"runtime"
 	"strings"
 	"sync/atomic"
 	"unsafe"
-
-	"github.com/tetratelabs/wazero/api"
 )
 
 // Conn is a database connection handle.
@@ -18,11 +16,9 @@ import (
 //
 // https://www.sqlite.org/c3ref/sqlite3.html
 type Conn struct {
-	ctx    context.Context
-	api    sqliteAPI
-	mem    memory
-	handle uint32
+	*module
 
+	handle    uint32
 	arena     arena
 	interrupt context.Context
 	waiter    chan struct{}
@@ -30,8 +26,8 @@ type Conn struct {
 }
 
 // Open calls [OpenFlags] with [OPEN_READWRITE], [OPEN_CREATE] and [OPEN_URI].
-func Open(filename string) (conn *Conn, err error) {
-	return OpenFlags(filename, OPEN_READWRITE|OPEN_CREATE|OPEN_URI)
+func Open(filename string) (*Conn, error) {
+	return newConn(filename, OPEN_READWRITE|OPEN_CREATE|OPEN_URI)
 }
 
 // OpenFlags opens an SQLite database file as specified by the filename argument.
@@ -41,33 +37,43 @@ func Open(filename string) (conn *Conn, err error) {
 //	sqlite3.Open("file:demo.db?_pragma=busy_timeout(10000)&_pragma=locking_mode(normal)")
 //
 // https://www.sqlite.org/c3ref/open.html
-func OpenFlags(filename string, flags OpenFlag) (conn *Conn, err error) {
-	ctx := context.Background()
-	module, err := sqlite3.instantiateModule(ctx)
+func OpenFlags(filename string, flags OpenFlag) (*Conn, error) {
+	return newConn(filename, flags)
+}
+
+func newConn(filename string, flags OpenFlag) (conn *Conn, err error) {
+	mod, err := instantiateModule()
 	if err != nil {
 		return nil, err
 	}
 	defer func() {
 		if conn == nil {
-			module.Close(ctx)
+			mod.close()
+		} else {
+			runtime.SetFinalizer(conn, finalizer[Conn](3))
 		}
 	}()
 
-	c, err := newConn(ctx, module)
+	c := &Conn{module: mod}
+	c.arena = c.newArena(1024)
+	c.handle, err = c.openDB(filename, flags)
 	if err != nil {
 		return nil, err
 	}
-	c.arena = c.newArena(1024)
+	return c, nil
+}
 
+func (c *Conn) openDB(filename string, flags OpenFlag) (uint32, error) {
 	defer c.arena.reset()
 	connPtr := c.arena.new(ptrlen)
 	namePtr := c.arena.string(filename)
 
 	r := c.call(c.api.open, uint64(namePtr), uint64(connPtr), uint64(flags), 0)
 
-	c.handle = c.mem.readUint32(connPtr)
-	if err := c.error(r[0]); err != nil {
-		return nil, err
+	handle := c.mem.readUint32(connPtr)
+	if err := c.module.error(r[0], handle); err != nil {
+		c.closeDB(handle)
+		return 0, err
 	}
 
 	if flags|OPEN_URI != 0 && strings.HasPrefix(filename, "file:") {
@@ -80,11 +86,22 @@ func OpenFlags(filename string, flags OpenFlag) (conn *Conn, err error) {
 				pragmas.WriteByte(';')
 			}
 		}
-		if err := c.Exec(pragmas.String()); err != nil {
-			return nil, fmt.Errorf("sqlite3: invalid _pragma: %w", err)
+
+		pragmaPtr := c.arena.string(pragmas.String())
+		r := c.call(c.api.exec, uint64(handle), uint64(pragmaPtr), 0, 0, 0)
+		if err := c.module.error(r[0], handle, pragmas.String()); err != nil {
+			c.closeDB(handle)
+			return 0, fmt.Errorf("sqlite3: invalid _pragma: %w", err)
 		}
 	}
-	return c, nil
+	return handle, nil
+}
+
+func (c *Conn) closeDB(handle uint32) {
+	r := c.call(c.api.closeZombie, uint64(handle))
+	if err := c.module.error(r[0], handle); err != nil {
+		panic(err)
+	}
 }
 
 // Close closes the database connection.
@@ -109,7 +126,8 @@ func (c *Conn) Close() error {
 	}
 
 	c.handle = 0
-	return c.mem.mod.Close(c.ctx)
+	runtime.SetFinalizer(c, nil)
+	return c.module.close()
 }
 
 // Exec is a convenience function that allows an application to run
@@ -136,6 +154,7 @@ func (c *Conn) MustPrepare(sql string) *Stmt {
 		panic(emptyErr)
 	}
 	if !emptyStatement(tail) {
+		s.Close()
 		panic(tailErr)
 	}
 	return s
@@ -299,132 +318,7 @@ func (c *Conn) Pragma(str string) []string {
 }
 
 func (c *Conn) error(rc uint64, sql ...string) error {
-	if rc == _OK {
-		return nil
-	}
-
-	err := Error{code: rc}
-
-	if err.Code() == NOMEM || err.ExtendedCode() == IOERR_NOMEM {
-		panic(oomErr)
-	}
-
-	var r []uint64
-
-	r, _ = c.api.errstr.Call(c.ctx, rc)
-	if r != nil {
-		err.str = c.mem.readString(uint32(r[0]), _MAX_STRING)
-	}
-
-	r, _ = c.api.errmsg.Call(c.ctx, uint64(c.handle))
-	if r != nil {
-		err.msg = c.mem.readString(uint32(r[0]), _MAX_STRING)
-	}
-
-	if sql != nil {
-		r, _ = c.api.erroff.Call(c.ctx, uint64(c.handle))
-		if r != nil && r[0] != math.MaxUint32 {
-			err.sql = sql[0][r[0]:]
-		}
-	}
-
-	switch err.msg {
-	case err.str, "not an error":
-		err.msg = ""
-	}
-	return &err
-}
-
-func (c *Conn) call(fn api.Function, params ...uint64) []uint64 {
-	r, err := fn.Call(c.ctx, params...)
-	if err != nil {
-		panic(err)
-	}
-	return r
-}
-
-func (c *Conn) free(ptr uint32) {
-	if ptr == 0 {
-		return
-	}
-	c.call(c.api.free, uint64(ptr))
-}
-
-func (c *Conn) new(size uint64) uint32 {
-	if size > _MAX_ALLOCATION_SIZE {
-		panic(oomErr)
-	}
-	r := c.call(c.api.malloc, size)
-	ptr := uint32(r[0])
-	if ptr == 0 && size != 0 {
-		panic(oomErr)
-	}
-	return ptr
-}
-
-func (c *Conn) newBytes(b []byte) uint32 {
-	if b == nil {
-		return 0
-	}
-	ptr := c.new(uint64(len(b)))
-	c.mem.writeBytes(ptr, b)
-	return ptr
-}
-
-func (c *Conn) newString(s string) uint32 {
-	ptr := c.new(uint64(len(s) + 1))
-	c.mem.writeString(ptr, s)
-	return ptr
-}
-
-func (c *Conn) newArena(size uint64) arena {
-	return arena{
-		c:    c,
-		base: c.new(size),
-		size: uint32(size),
-	}
-}
-
-type arena struct {
-	c    *Conn
-	base uint32
-	next uint32
-	size uint32
-	ptrs []uint32
-}
-
-func (a *arena) free() {
-	if a.c == nil {
-		return
-	}
-	a.reset()
-	a.c.free(a.base)
-	a.c = nil
-}
-
-func (a *arena) reset() {
-	for _, ptr := range a.ptrs {
-		a.c.free(ptr)
-	}
-	a.ptrs = nil
-	a.next = 0
-}
-
-func (a *arena) new(size uint64) uint32 {
-	if size <= uint64(a.size-a.next) {
-		ptr := a.base + a.next
-		a.next += uint32(size)
-		return ptr
-	}
-	ptr := a.c.new(size)
-	a.ptrs = append(a.ptrs, ptr)
-	return ptr
-}
-
-func (a *arena) string(s string) uint32 {
-	ptr := a.new(uint64(len(s) + 1))
-	a.c.mem.writeString(ptr, s)
-	return ptr
+	return c.module.error(rc, c.handle, sql...)
 }
 
 // DriverConn is implemented by the SQLite [database/sql] driver connection.

driver/example_test.go

@@ -28,8 +28,8 @@ func Example() {
 	if err != nil {
 		log.Fatal(err)
 	}
-	defer db.Close()
 	defer os.Remove("./recordings.db")
+	defer db.Close()
 
 	// Create a table with some data in it.
 	err = albumsSetup()

driver_test.go

@@ -20,8 +20,8 @@ func ExampleDriverConn() {
 	if err != nil {
 		log.Fatal(err)
 	}
-	defer db.Close()
 	defer os.Remove("demo.db")
+	defer db.Close()
 
 	ctx := context.Background()
 

embed/build.sh

@@ -13,51 +13,4 @@ zig cc --target=wasm32-wasi -flto -g0 -Os \
 	-mbulk-memory -mreference-types \
 	-mnontrapping-fptoint -msign-ext \
 	-D_HAVE_SQLITE_CONFIG_H \
-	-Wl,--export=free \
-	-Wl,--export=malloc \
-	-Wl,--export=malloc_destructor \
-	-Wl,--export=sqlite3_errcode \
-	-Wl,--export=sqlite3_errstr \
-	-Wl,--export=sqlite3_errmsg \
-	-Wl,--export=sqlite3_error_offset \
-	-Wl,--export=sqlite3_open_v2 \
-	-Wl,--export=sqlite3_close \
-	-Wl,--export=sqlite3_prepare_v3 \
-	-Wl,--export=sqlite3_finalize \
-	-Wl,--export=sqlite3_reset \
-	-Wl,--export=sqlite3_step \
-	-Wl,--export=sqlite3_exec \
-	-Wl,--export=sqlite3_clear_bindings \
-	-Wl,--export=sqlite3_bind_parameter_count \
-	-Wl,--export=sqlite3_bind_parameter_index \
-	-Wl,--export=sqlite3_bind_parameter_name \
-	-Wl,--export=sqlite3_bind_null \
-	-Wl,--export=sqlite3_bind_int64 \
-	-Wl,--export=sqlite3_bind_double \
-	-Wl,--export=sqlite3_bind_text64 \
-	-Wl,--export=sqlite3_bind_blob64 \
-	-Wl,--export=sqlite3_bind_zeroblob64 \
-	-Wl,--export=sqlite3_column_count \
-	-Wl,--export=sqlite3_column_name \
-	-Wl,--export=sqlite3_column_type \
-	-Wl,--export=sqlite3_column_int64 \
-	-Wl,--export=sqlite3_column_double \
-	-Wl,--export=sqlite3_column_text \
-	-Wl,--export=sqlite3_column_blob \
-	-Wl,--export=sqlite3_column_bytes \
-	-Wl,--export=sqlite3_blob_open \
-	-Wl,--export=sqlite3_blob_close \
-	-Wl,--export=sqlite3_blob_bytes \
-	-Wl,--export=sqlite3_blob_read \
-	-Wl,--export=sqlite3_blob_write \
-	-Wl,--export=sqlite3_blob_reopen \
-	-Wl,--export=sqlite3_get_autocommit \
-	-Wl,--export=sqlite3_last_insert_rowid \
-	-Wl,--export=sqlite3_changes64 \
-	-Wl,--export=sqlite3_unlock_notify \
-	-Wl,--export=sqlite3_backup_init \
-	-Wl,--export=sqlite3_backup_step \
-	-Wl,--export=sqlite3_backup_finish \
-	-Wl,--export=sqlite3_backup_remaining \
-	-Wl,--export=sqlite3_backup_pagecount \
-	-Wl,--export=sqlite3_interrupt_offset \
+	$(awk '{print "-Wl,--export="$0}' ../sqlite3/exports.txt)

error.go

@@ -1,6 +1,7 @@
 package sqlite3
 
 import (
+	"fmt"
 	"runtime"
 	"strconv"
 	"strings"
@@ -215,3 +216,11 @@ func assertErr() errorString {
 	}
 	return errorString(msg)
 }
+
+func finalizer[T any](skip int) func(*T) {
+	msg := fmt.Sprintf("sqlite3: %T not closed", new(T))
+	if _, file, line, ok := runtime.Caller(skip + 1); ok && skip >= 0 {
+		msg += " (" + file + ":" + strconv.Itoa(line) + ")"
+	}
+	return func(*T) { panic(errorString(msg)) }
+}

go.mod

@@ -4,7 +4,9 @@ go 1.19
 
 require (
 	github.com/ncruces/julianday v0.1.5
-	github.com/tetratelabs/wazero v1.0.0-pre.9
+	github.com/tetratelabs/wazero v1.0.0-rc.1
 	golang.org/x/sync v0.1.0
-	golang.org/x/sys v0.5.0
+	golang.org/x/sys v0.6.0
 )
+
+retract v0.4.0 // tagged from the wrong branch

go.sum

@@ -1,8 +1,8 @@
 github.com/ncruces/julianday v0.1.5 h1:hDJ9ejiMp3DHsoZ5KW4c1lwfMjbARS7u/gbYcd0FBZk=
 github.com/ncruces/julianday v0.1.5/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
-github.com/tetratelabs/wazero v1.0.0-pre.9 h1:2uVdi2bvTi/JQxG2cp3LRm2aRadd3nURn5jcfbvqZcw=
-github.com/tetratelabs/wazero v1.0.0-pre.9/go.mod h1:wYx2gNRg8/WihJfSDxA1TIL8H+GkfLYm+bIfbblu9VQ=
+github.com/tetratelabs/wazero v1.0.0-rc.1 h1:ytecMV5Ue0BwezjKh/cM5yv1Mo49ep2R2snSsQUyToc=
+github.com/tetratelabs/wazero v1.0.0-rc.1/go.mod h1:wYx2gNRg8/WihJfSDxA1TIL8H+GkfLYm+bIfbblu9VQ=
 golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU=
-golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0 h1:MVltZSvRTcU2ljQOhs94SXPftV6DCNnZViHeQps87pQ=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

module.go

@@ -0,0 +1,352 @@
+// Package sqlite3 wraps the C SQLite API.
+package sqlite3
+
+import (
+	"context"
+	"crypto/rand"
+	"io"
+	"math"
+	"os"
+	"runtime"
+	"strconv"
+	"sync"
+	"sync/atomic"
+
+	"github.com/tetratelabs/wazero"
+	"github.com/tetratelabs/wazero/api"
+)
+
+// Configure SQLite WASM.
+//
+// Importing package embed initializes these
+// with an appropriate build of SQLite:
+//
+//	import _ "github.com/ncruces/go-sqlite3/embed"
+var (
+	Binary []byte // WASM binary to load.
+	Path   string // Path to load the binary from.
+)
+
+var sqlite3 struct {
+	once      sync.Once
+	runtime   wazero.Runtime
+	compiled  wazero.CompiledModule
+	instances atomic.Uint64
+	err       error
+}
+
+func instantiateModule() (*module, error) {
+	ctx := context.Background()
+
+	sqlite3.once.Do(compileModule)
+	if sqlite3.err != nil {
+		return nil, sqlite3.err
+	}
+
+	name := "sqlite3-" + strconv.FormatUint(sqlite3.instances.Add(1), 10)
+
+	cfg := wazero.NewModuleConfig().WithName(name).
+		WithSysWalltime().WithSysNanotime().WithSysNanosleep().
+		WithOsyield(runtime.Gosched).
+		WithRandSource(rand.Reader)
+
+	mod, err := sqlite3.runtime.InstantiateModule(ctx, sqlite3.compiled, cfg)
+	if err != nil {
+		return nil, err
+	}
+	return newModule(mod)
+}
+
+func compileModule() {
+	ctx := context.Background()
+	sqlite3.runtime = wazero.NewRuntime(ctx)
+	vfsInstantiate(ctx, sqlite3.runtime)
+
+	bin := Binary
+	if bin == nil && Path != "" {
+		bin, sqlite3.err = os.ReadFile(Path)
+		if sqlite3.err != nil {
+			return
+		}
+	}
+	if bin == nil {
+		sqlite3.err = binaryErr
+		return
+	}
+
+	sqlite3.compiled, sqlite3.err = sqlite3.runtime.CompileModule(ctx, bin)
+}
+
+type module struct {
+	ctx context.Context
+	mem memory
+	api sqliteAPI
+	vfs io.Closer
+}
+
+func newModule(mod api.Module) (m *module, err error) {
+	m = &module{}
+	m.mem = memory{mod}
+	m.ctx, m.vfs = vfsContext(context.Background())
+
+	getFun := func(name string) api.Function {
+		f := mod.ExportedFunction(name)
+		if f == nil {
+			err = noFuncErr + errorString(name)
+			return nil
+		}
+		return f
+	}
+
+	getVal := func(name string) uint32 {
+		global := mod.ExportedGlobal(name)
+		if global == nil {
+			err = noGlobalErr + errorString(name)
+			return 0
+		}
+		return m.mem.readUint32(uint32(global.Get()))
+	}
+
+	m.api = sqliteAPI{
+		free:            getFun("free"),
+		malloc:          getFun("malloc"),
+		destructor:      uint64(getVal("malloc_destructor")),
+		errcode:         getFun("sqlite3_errcode"),
+		errstr:          getFun("sqlite3_errstr"),
+		errmsg:          getFun("sqlite3_errmsg"),
+		erroff:          getFun("sqlite3_error_offset"),
+		open:            getFun("sqlite3_open_v2"),
+		close:           getFun("sqlite3_close"),
+		closeZombie:     getFun("sqlite3_close_v2"),
+		prepare:         getFun("sqlite3_prepare_v3"),
+		finalize:        getFun("sqlite3_finalize"),
+		reset:           getFun("sqlite3_reset"),
+		step:            getFun("sqlite3_step"),
+		exec:            getFun("sqlite3_exec"),
+		clearBindings:   getFun("sqlite3_clear_bindings"),
+		bindCount:       getFun("sqlite3_bind_parameter_count"),
+		bindIndex:       getFun("sqlite3_bind_parameter_index"),
+		bindName:        getFun("sqlite3_bind_parameter_name"),
+		bindNull:        getFun("sqlite3_bind_null"),
+		bindInteger:     getFun("sqlite3_bind_int64"),
+		bindFloat:       getFun("sqlite3_bind_double"),
+		bindText:        getFun("sqlite3_bind_text64"),
+		bindBlob:        getFun("sqlite3_bind_blob64"),
+		bindZeroBlob:    getFun("sqlite3_bind_zeroblob64"),
+		columnCount:     getFun("sqlite3_column_count"),
+		columnName:      getFun("sqlite3_column_name"),
+		columnType:      getFun("sqlite3_column_type"),
+		columnInteger:   getFun("sqlite3_column_int64"),
+		columnFloat:     getFun("sqlite3_column_double"),
+		columnText:      getFun("sqlite3_column_text"),
+		columnBlob:      getFun("sqlite3_column_blob"),
+		columnBytes:     getFun("sqlite3_column_bytes"),
+		autocommit:      getFun("sqlite3_get_autocommit"),
+		lastRowid:       getFun("sqlite3_last_insert_rowid"),
+		changes:         getFun("sqlite3_changes64"),
+		blobOpen:        getFun("sqlite3_blob_open"),
+		blobClose:       getFun("sqlite3_blob_close"),
+		blobReopen:      getFun("sqlite3_blob_reopen"),
+		blobBytes:       getFun("sqlite3_blob_bytes"),
+		blobRead:        getFun("sqlite3_blob_read"),
+		blobWrite:       getFun("sqlite3_blob_write"),
+		backupInit:      getFun("sqlite3_backup_init"),
+		backupStep:      getFun("sqlite3_backup_step"),
+		backupFinish:    getFun("sqlite3_backup_finish"),
+		backupRemaining: getFun("sqlite3_backup_remaining"),
+		backupPageCount: getFun("sqlite3_backup_pagecount"),
+		interrupt:       getVal("sqlite3_interrupt_offset"),
+	}
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (m *module) close() error {
+	err := m.mem.mod.Close(m.ctx)
+	m.vfs.Close()
+	return err
+}
+
+func (m *module) error(rc uint64, handle uint32, sql ...string) error {
+	if rc == _OK {
+		return nil
+	}
+
+	err := Error{code: rc}
+
+	if err.Code() == NOMEM || err.ExtendedCode() == IOERR_NOMEM {
+		panic(oomErr)
+	}
+
+	var r []uint64
+
+	r = m.call(m.api.errstr, rc)
+	if r != nil {
+		err.str = m.mem.readString(uint32(r[0]), _MAX_STRING)
+	}
+
+	r = m.call(m.api.errmsg, uint64(handle))
+	if r != nil {
+		err.msg = m.mem.readString(uint32(r[0]), _MAX_STRING)
+	}
+
+	if sql != nil {
+		r = m.call(m.api.erroff, uint64(handle))
+		if r != nil && r[0] != math.MaxUint32 {
+			err.sql = sql[0][r[0]:]
+		}
+	}
+
+	switch err.msg {
+	case err.str, "not an error":
+		err.msg = ""
+	}
+	return &err
+}
+
+func (m *module) call(fn api.Function, params ...uint64) []uint64 {
+	r, err := fn.Call(m.ctx, params...)
+	if err != nil {
+		// The module closed or panicked; release resources.
+		m.vfs.Close()
+		panic(err)
+	}
+	return r
+}
+
+func (m *module) free(ptr uint32) {
+	if ptr == 0 {
+		return
+	}
+	m.call(m.api.free, uint64(ptr))
+}
+
+func (m *module) new(size uint64) uint32 {
+	if size > _MAX_ALLOCATION_SIZE {
+		panic(oomErr)
+	}
+	r := m.call(m.api.malloc, size)
+	ptr := uint32(r[0])
+	if ptr == 0 && size != 0 {
+		panic(oomErr)
+	}
+	return ptr
+}
+
+func (m *module) newBytes(b []byte) uint32 {
+	if b == nil {
+		return 0
+	}
+	ptr := m.new(uint64(len(b)))
+	m.mem.writeBytes(ptr, b)
+	return ptr
+}
+
+func (m *module) newString(s string) uint32 {
+	ptr := m.new(uint64(len(s) + 1))
+	m.mem.writeString(ptr, s)
+	return ptr
+}
+
+func (m *module) newArena(size uint64) arena {
+	return arena{
+		m:    m,
+		base: m.new(size),
+		size: uint32(size),
+	}
+}
+
+type arena struct {
+	m    *module
+	base uint32
+	next uint32
+	size uint32
+	ptrs []uint32
+}
+
+func (a *arena) free() {
+	if a.m == nil {
+		return
+	}
+	a.reset()
+	a.m.free(a.base)
+	a.m = nil
+}
+
+func (a *arena) reset() {
+	for _, ptr := range a.ptrs {
+		a.m.free(ptr)
+	}
+	a.ptrs = nil
+	a.next = 0
+}
+
+func (a *arena) new(size uint64) uint32 {
+	if size <= uint64(a.size-a.next) {
+		ptr := a.base + a.next
+		a.next += uint32(size)
+		return ptr
+	}
+	ptr := a.m.new(size)
+	a.ptrs = append(a.ptrs, ptr)
+	return ptr
+}
+
+func (a *arena) string(s string) uint32 {
+	ptr := a.new(uint64(len(s) + 1))
+	a.m.mem.writeString(ptr, s)
+	return ptr
+}
+
+type sqliteAPI struct {
+	free            api.Function
+	malloc          api.Function
+	destructor      uint64
+	errcode         api.Function
+	errstr          api.Function
+	errmsg          api.Function
+	erroff          api.Function
+	open            api.Function
+	close           api.Function
+	closeZombie     api.Function
+	prepare         api.Function
+	finalize        api.Function
+	reset           api.Function
+	step            api.Function
+	exec            api.Function
+	clearBindings   api.Function
+	bindNull        api.Function
+	bindCount       api.Function
+	bindIndex       api.Function
+	bindName        api.Function
+	bindInteger     api.Function
+	bindFloat       api.Function
+	bindText        api.Function
+	bindBlob        api.Function
+	bindZeroBlob    api.Function
+	columnCount     api.Function
+	columnName      api.Function
+	columnType      api.Function
+	columnInteger   api.Function
+	columnFloat     api.Function
+	columnText      api.Function
+	columnBlob      api.Function
+	columnBytes     api.Function
+	autocommit      api.Function
+	lastRowid       api.Function
+	changes         api.Function
+	blobOpen        api.Function
+	blobClose       api.Function
+	blobReopen      api.Function
+	blobBytes       api.Function
+	blobRead        api.Function
+	blobWrite       api.Function
+	backupInit      api.Function
+	backupStep      api.Function
+	backupFinish    api.Function
+	backupRemaining api.Function
+	backupPageCount api.Function
+	interrupt       uint32
+}

module_test.go

@@ -9,43 +9,43 @@ import (
 func TestConn_error_OOM(t *testing.T) {
 	t.Parallel()
 
-	db, err := Open(":memory:")
+	m, err := instantiateModule()
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer db.Close()
+	defer m.close()
 
 	defer func() { _ = recover() }()
-	db.error(uint64(NOMEM))
+	m.error(uint64(NOMEM), 0)
 	t.Error("want panic")
 }
 
 func TestConn_call_nil(t *testing.T) {
 	t.Parallel()
 
-	db, err := Open(":memory:")
+	m, err := instantiateModule()
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer db.Close()
+	defer m.close()
 
 	defer func() { _ = recover() }()
-	db.call(db.api.free)
+	m.call(m.api.free)
 	t.Error("want panic")
 }
 
 func TestConn_new(t *testing.T) {
 	t.Parallel()
 
-	db, err := Open(":memory:")
+	m, err := instantiateModule()
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer db.Close()
+	defer m.close()
 
 	testOOM := func(size uint64) {
 		defer func() { _ = recover() }()
-		db.new(size)
+		m.new(size)
 		t.Error("want panic")
 	}
 
@@ -56,13 +56,13 @@ func TestConn_new(t *testing.T) {
 func TestConn_newArena(t *testing.T) {
 	t.Parallel()
 
-	db, err := Open(":memory:")
+	m, err := instantiateModule()
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer db.Close()
+	defer m.close()
 
-	arena := db.newArena(16)
+	arena := m.newArena(16)
 	defer arena.free()
 
 	const title = "Lorem ipsum"
@@ -71,7 +71,7 @@ func TestConn_newArena(t *testing.T) {
 	if ptr == 0 {
 		t.Fatalf("got nullptr")
 	}
-	if got := db.mem.readString(ptr, math.MaxUint32); got != title {
+	if got := m.mem.readString(ptr, math.MaxUint32); got != title {
 		t.Errorf("got %q, want %q", got, title)
 	}
 
@@ -80,7 +80,7 @@ func TestConn_newArena(t *testing.T) {
 	if ptr == 0 {
 		t.Fatalf("got nullptr")
 	}
-	if got := db.mem.readString(ptr, math.MaxUint32); got != body {
+	if got := m.mem.readString(ptr, math.MaxUint32); got != body {
 		t.Errorf("got %q, want %q", got, body)
 	}
 	arena.free()
@@ -89,25 +89,25 @@ func TestConn_newArena(t *testing.T) {
 func TestConn_newBytes(t *testing.T) {
 	t.Parallel()
 
-	db, err := Open(":memory:")
+	m, err := instantiateModule()
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer db.Close()
+	defer m.close()
 
-	ptr := db.newBytes(nil)
+	ptr := m.newBytes(nil)
 	if ptr != 0 {
 		t.Errorf("got %#x, want nullptr", ptr)
 	}
 
 	buf := []byte("sqlite3")
-	ptr = db.newBytes(buf)
+	ptr = m.newBytes(buf)
 	if ptr == 0 {
 		t.Fatal("got nullptr, want a pointer")
 	}
 
 	want := buf
-	if got := db.mem.view(ptr, uint64(len(want))); !bytes.Equal(got, want) {
+	if got := m.mem.view(ptr, uint64(len(want))); !bytes.Equal(got, want) {
 		t.Errorf("got %q, want %q", got, want)
 	}
 }
@@ -115,25 +115,25 @@ func TestConn_newBytes(t *testing.T) {
 func TestConn_newString(t *testing.T) {
 	t.Parallel()
 
-	db, err := Open(":memory:")
+	m, err := instantiateModule()
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer db.Close()
+	defer m.close()
 
-	ptr := db.newString("")
+	ptr := m.newString("")
 	if ptr == 0 {
 		t.Error("got nullptr, want a pointer")
 	}
 
 	str := "sqlite3\000sqlite3"
-	ptr = db.newString(str)
+	ptr = m.newString(str)
 	if ptr == 0 {
 		t.Fatal("got nullptr, want a pointer")
 	}
 
 	want := str + "\000"
-	if got := db.mem.view(ptr, uint64(len(want))); string(got) != want {
+	if got := m.mem.view(ptr, uint64(len(want))); string(got) != want {
 		t.Errorf("got %q, want %q", got, want)
 	}
 }
@@ -141,40 +141,40 @@ func TestConn_newString(t *testing.T) {
 func TestConn_getString(t *testing.T) {
 	t.Parallel()
 
-	db, err := Open(":memory:")
+	m, err := instantiateModule()
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer db.Close()
+	defer m.close()
 
-	ptr := db.newString("")
+	ptr := m.newString("")
 	if ptr == 0 {
 		t.Error("got nullptr, want a pointer")
 	}
 
 	str := "sqlite3" + "\000 drop this"
-	ptr = db.newString(str)
+	ptr = m.newString(str)
 	if ptr == 0 {
 		t.Fatal("got nullptr, want a pointer")
 	}
 
 	want := "sqlite3"
-	if got := db.mem.readString(ptr, math.MaxUint32); got != want {
+	if got := m.mem.readString(ptr, math.MaxUint32); got != want {
 		t.Errorf("got %q, want %q", got, want)
 	}
-	if got := db.mem.readString(ptr, 0); got != "" {
+	if got := m.mem.readString(ptr, 0); got != "" {
 		t.Errorf("got %q, want empty", got)
 	}
 
 	func() {
 		defer func() { _ = recover() }()
-		db.mem.readString(ptr, uint32(len(want)/2))
+		m.mem.readString(ptr, uint32(len(want)/2))
 		t.Error("want panic")
 	}()
 
 	func() {
 		defer func() { _ = recover() }()
-		db.mem.readString(0, math.MaxUint32)
+		m.mem.readString(0, math.MaxUint32)
 		t.Error("want panic")
 	}()
 }
@@ -182,18 +182,18 @@ func TestConn_getString(t *testing.T) {
 func TestConn_free(t *testing.T) {
 	t.Parallel()
 
-	db, err := Open(":memory:")
+	m, err := instantiateModule()
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer db.Close()
+	defer m.close()
 
-	db.free(0)
+	m.free(0)
 
-	ptr := db.new(1)
+	ptr := m.new(1)
 	if ptr == 0 {
 		t.Error("got nullptr, want a pointer")
 	}
 
-	db.free(ptr)
+	m.free(ptr)
 }

sqlite3/.gitignore

@@ -0,0 +1,3 @@
+sqlite3.c
+sqlite3.h
+sqlite3ext.h

sqlite3/exports.txt

@@ -0,0 +1,49 @@
+free
+malloc
+malloc_destructor
+sqlite3_errcode
+sqlite3_errstr
+sqlite3_errmsg
+sqlite3_error_offset
+sqlite3_open_v2
+sqlite3_close
+sqlite3_close_v2
+sqlite3_prepare_v3
+sqlite3_finalize
+sqlite3_reset
+sqlite3_step
+sqlite3_exec
+sqlite3_clear_bindings
+sqlite3_bind_parameter_count
+sqlite3_bind_parameter_index
+sqlite3_bind_parameter_name
+sqlite3_bind_null
+sqlite3_bind_int64
+sqlite3_bind_double
+sqlite3_bind_text64
+sqlite3_bind_blob64
+sqlite3_bind_zeroblob64
+sqlite3_column_count
+sqlite3_column_name
+sqlite3_column_type
+sqlite3_column_int64
+sqlite3_column_double
+sqlite3_column_text
+sqlite3_column_blob
+sqlite3_column_bytes
+sqlite3_blob_open
+sqlite3_blob_close
+sqlite3_blob_bytes
+sqlite3_blob_read
+sqlite3_blob_write
+sqlite3_blob_reopen
+sqlite3_get_autocommit
+sqlite3_last_insert_rowid
+sqlite3_changes64
+sqlite3_unlock_notify
+sqlite3_backup_init
+sqlite3_backup_step
+sqlite3_backup_finish
+sqlite3_backup_remaining
+sqlite3_backup_pagecount
+sqlite3_interrupt_offset

sqlite3/sqlite_cfg.h

@@ -33,7 +33,9 @@
 // We set the default locking mode to EXCLUSIVE instead.
 // https://www.sqlite.org/wal.html#noshm
 #undef SQLITE_OMIT_WAL
+#ifndef SQLITE_DEFAULT_LOCKING_MODE
 #define SQLITE_DEFAULT_LOCKING_MODE 1
+#endif
 
 // Recommended Extensions
 

stmt.go

@@ -339,7 +339,7 @@ func (s *Stmt) ColumnText(col int) string {
 
 	ptr := uint32(r[0])
 	if ptr == 0 {
-		r = s.c.call(s.c.api.errcode, uint64(s.handle))
+		r = s.c.call(s.c.api.errcode, uint64(s.c.handle))
 		s.err = s.c.error(r[0])
 		return ""
 	}
@@ -362,7 +362,7 @@ func (s *Stmt) ColumnBlob(col int, buf []byte) []byte {
 
 	ptr := uint32(r[0])
 	if ptr == 0 {
-		r = s.c.call(s.c.api.errcode, uint64(s.handle))
+		r = s.c.call(s.c.api.errcode, uint64(s.c.handle))
 		s.err = s.c.error(r[0])
 		return buf[0:0]
 	}

tests/backup_test.go

@@ -0,0 +1,127 @@
+package tests
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+	_ "github.com/ncruces/go-sqlite3/embed"
+)
+
+func TestBackup(t *testing.T) {
+	t.Parallel()
+
+	backupName := filepath.Join(t.TempDir(), "backup.db")
+
+	func() { // Create backup.
+		db, err := sqlite3.Open(":memory:")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer db.Close()
+
+		err = db.Exec(`CREATE TABLE IF NOT EXISTS users (id INT, name VARCHAR(10))`)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = db.Exec(`INSERT INTO users (id, name) VALUES (0, 'go'), (1, 'zig'), (2, 'whatever')`)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = db.Backup("main", backupName)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = db.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+
+	func() { // Restore backup.
+		db, err := sqlite3.Open(":memory:")
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer db.Close()
+
+		err = db.Restore("main", backupName)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		stmt, _, err := db.Prepare(`SELECT id, name FROM users`)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer stmt.Close()
+
+		row := 0
+		ids := []int{0, 1, 2}
+		names := []string{"go", "zig", "whatever"}
+		for ; stmt.Step(); row++ {
+			id := stmt.ColumnInt(0)
+			name := stmt.ColumnText(1)
+
+			if id != ids[row] {
+				t.Errorf("got %d, want %d", id, ids[row])
+			}
+			if name != names[row] {
+				t.Errorf("got %q, want %q", name, names[row])
+			}
+		}
+		if row != 3 {
+			t.Errorf("got %d, want %d", row, len(ids))
+		}
+
+		if err := stmt.Err(); err != nil {
+			t.Fatal(err)
+		}
+
+		err = stmt.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = db.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+
+	func() { // Errors.
+		db, err := sqlite3.Open(backupName)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer db.Close()
+
+		tx, err := db.BeginExclusive()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = db.Restore("main", backupName)
+		if err == nil {
+			t.Fatal("want error")
+		}
+
+		err = tx.Rollback()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = db.Restore("main", backupName)
+		if err == nil {
+			t.Fatal("want error")
+		}
+
+		err = db.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+}

tests/mptest/mptest_test.go

@@ -0,0 +1,182 @@
+package mptest
+
+import (
+	"bytes"
+	"context"
+	"crypto/rand"
+	"embed"
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+
+	_ "unsafe"
+
+	"github.com/tetratelabs/wazero"
+	"github.com/tetratelabs/wazero/api"
+	"github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1"
+
+	_ "github.com/ncruces/go-sqlite3"
+)
+
+//go:embed testdata/mptest.wasm
+var binary []byte
+
+//go:embed testdata/*.*test
+var scripts embed.FS
+
+//go:linkname vfsNewEnvModuleBuilder github.com/ncruces/go-sqlite3.vfsNewEnvModuleBuilder
+func vfsNewEnvModuleBuilder(r wazero.Runtime) wazero.HostModuleBuilder
+
+//go:linkname vfsContext github.com/ncruces/go-sqlite3.vfsContext
+func vfsContext(ctx context.Context) (context.Context, io.Closer)
+
+var (
+	rt        wazero.Runtime
+	module    wazero.CompiledModule
+	instances atomic.Uint64
+)
+
+func init() {
+	ctx := context.TODO()
+
+	rt = wazero.NewRuntime(ctx)
+	wasi_snapshot_preview1.MustInstantiate(ctx, rt)
+	env := vfsNewEnvModuleBuilder(rt)
+	env.NewFunctionBuilder().WithFunc(system).Export("system")
+	_, err := env.Instantiate(ctx)
+	if err != nil {
+		panic(err)
+	}
+
+	module, err = rt.CompileModule(ctx, binary)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func config(ctx context.Context) wazero.ModuleConfig {
+	name := strconv.FormatUint(instances.Add(1), 10)
+	log := ctx.Value(logger{}).(io.Writer)
+	fs, err := fs.Sub(scripts, "testdata")
+	if err != nil {
+		panic(err)
+	}
+
+	return wazero.NewModuleConfig().
+		WithName(name).WithStdout(log).WithStderr(log).WithFS(fs).
+		WithSysWalltime().WithSysNanotime().WithSysNanosleep().
+		WithOsyield(runtime.Gosched).
+		WithRandSource(rand.Reader)
+}
+
+func system(ctx context.Context, mod api.Module, ptr uint32) uint32 {
+	buf, _ := mod.Memory().Read(ptr, mod.Memory().Size()-ptr)
+	buf = buf[:bytes.IndexByte(buf, 0)]
+
+	args := strings.Split(string(buf), " ")
+	for i := range args {
+		args[i] = strings.Trim(args[i], `"`)
+	}
+	args = args[:len(args)-1]
+
+	cfg := config(ctx).WithArgs(args...)
+	go func() {
+		ctx, vfs := vfsContext(ctx)
+		rt.InstantiateModule(ctx, module, cfg)
+		vfs.Close()
+	}()
+	return 0
+}
+
+func Test_config01(t *testing.T) {
+	ctx, vfs := vfsContext(newContext(t))
+	name := filepath.Join(t.TempDir(), "test.db")
+	cfg := config(ctx).WithArgs("mptest", name, "config01.test")
+	_, err := rt.InstantiateModule(ctx, module, cfg)
+	if err != nil {
+		t.Error(err)
+	}
+	vfs.Close()
+}
+
+func Test_config02(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping in short mode")
+	}
+	if os.Getenv("CI") != "" {
+		t.Skip("skipping in CI")
+	}
+
+	ctx, vfs := vfsContext(newContext(t))
+	name := filepath.Join(t.TempDir(), "test.db")
+	cfg := config(ctx).WithArgs("mptest", name, "config02.test")
+	_, err := rt.InstantiateModule(ctx, module, cfg)
+	if err != nil {
+		t.Error(err)
+	}
+	vfs.Close()
+}
+
+func Test_crash01(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping in short mode")
+	}
+
+	ctx, vfs := vfsContext(newContext(t))
+	name := filepath.Join(t.TempDir(), "test.db")
+	cfg := config(ctx).WithArgs("mptest", name, "crash01.test")
+	_, err := rt.InstantiateModule(ctx, module, cfg)
+	if err != nil {
+		t.Error(err)
+	}
+	vfs.Close()
+}
+
+func Test_multiwrite01(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping in short mode")
+	}
+
+	ctx, vfs := vfsContext(newContext(t))
+	name := filepath.Join(t.TempDir(), "test.db")
+	cfg := config(ctx).WithArgs("mptest", name, "multiwrite01.test")
+	_, err := rt.InstantiateModule(ctx, module, cfg)
+	if err != nil {
+		t.Error(err)
+	}
+	vfs.Close()
+}
+
+func newContext(t *testing.T) context.Context {
+	return context.WithValue(context.Background(), logger{}, &testWriter{T: t})
+}
+
+type logger struct{}
+
+type testWriter struct {
+	*testing.T
+	buf []byte
+	mtx sync.Mutex
+}
+
+func (l *testWriter) Write(p []byte) (n int, err error) {
+	l.mtx.Lock()
+	defer l.mtx.Unlock()
+
+	l.buf = append(l.buf, p...)
+	for {
+		before, after, found := bytes.Cut(l.buf, []byte("\n"))
+		if !found {
+			return len(p), nil
+		}
+		l.Logf("%s", before)
+		l.buf = after
+	}
+}

tests/mptest/testdata/.gitattributes

@@ -0,0 +1,2 @@
+mptest.wasm filter=lfs diff=lfs merge=lfs -text
+*.*test -crlf

tests/mptest/testdata/.gitignore

@@ -0,0 +1 @@
+mptest.c

tests/mptest/testdata/build.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+set -eo pipefail
+
+cd -P -- "$(dirname -- "$0")"
+
+if [ ! -f "mptest.c" ]; then
+	curl -sOL	"https://github.com/sqlite/sqlite/raw/master/mptest/mptest.c"
+	curl -sOL "https://github.com/sqlite/sqlite/raw/master/mptest/config01.test"
+  curl -sOL "https://github.com/sqlite/sqlite/raw/master/mptest/config02.test"
+  curl -sOL "https://github.com/sqlite/sqlite/raw/master/mptest/crash01.test"
+  curl -sOL "https://github.com/sqlite/sqlite/raw/master/mptest/crash02.subtest"
+  curl -sOL "https://github.com/sqlite/sqlite/raw/master/mptest/multiwrite01.test"
+fi
+
+zig cc --target=wasm32-wasi -flto -g0 -Os \
+  -o mptest.wasm main.c test.c \
+	-I../../../sqlite3 \
+	-mmutable-globals \
+	-mbulk-memory -mreference-types \
+	-mnontrapping-fptoint -msign-ext \
+	-D_HAVE_SQLITE_CONFIG_H \
+	-DSQLITE_DEFAULT_SYNCHRONOUS=0 \
+	-DSQLITE_DEFAULT_LOCKING_MODE=0 \
+	-DHAVE_USLEEP -DSQLITE_NO_SYNC \
+	-DSQLITE_THREADSAFE=0 -DSQLITE_OMIT_LOAD_EXTENSION \
+	-D_WASI_EMULATED_GETPID -lwasi-emulated-getpid

tests/mptest/testdata/config01.test

@@ -0,0 +1,46 @@
+/*
+** Configure five tasks in different ways, then run tests.
+*/
+--if vfsname() GLOB 'unix'
+PRAGMA page_size=8192;
+--task 1
+  PRAGMA journal_mode=PERSIST;
+  PRAGMA mmap_size=0;
+--end
+--task 2
+  PRAGMA journal_mode=TRUNCATE;
+  PRAGMA mmap_size=28672;
+--end
+--task 3
+  PRAGMA journal_mode=MEMORY;
+--end
+--task 4
+  PRAGMA journal_mode=OFF;
+--end
+--task 4
+  PRAGMA mmap_size(268435456);
+--end
+--source multiwrite01.test
+--wait all
+PRAGMA page_size=16384;
+VACUUM;
+CREATE TABLE pgsz(taskid, sz INTEGER);
+--task 1
+  INSERT INTO pgsz VALUES(1, eval('PRAGMA page_size'));
+--end
+--task 2
+  INSERT INTO pgsz VALUES(2, eval('PRAGMA page_size'));
+--end
+--task 3
+  INSERT INTO pgsz VALUES(3, eval('PRAGMA page_size'));
+--end
+--task 4
+  INSERT INTO pgsz VALUES(4, eval('PRAGMA page_size'));
+--end
+--task 5
+  INSERT INTO pgsz VALUES(5, eval('PRAGMA page_size'));
+--end
+--source multiwrite01.test
+--wait all
+SELECT sz FROM pgsz;
+--match 16384 16384 16384 16384 16384

tests/mptest/testdata/config02.test

@@ -0,0 +1,123 @@
+/*
+** Configure five tasks in different ways, then run tests.
+*/
+PRAGMA page_size=512;
+--task 1
+  PRAGMA mmap_size=0;
+--end
+--task 2
+  PRAGMA mmap_size=28672;
+--end
+--task 3
+  PRAGMA mmap_size=8192;
+--end
+--task 4
+  PRAGMA mmap_size=65536;
+--end
+--task 5
+  PRAGMA mmap_size=268435456;
+--end
+--source multiwrite01.test
+--source crash02.subtest
+PRAGMA page_size=1024;
+VACUUM;
+CREATE TABLE pgsz(taskid, sz INTEGER);
+--task 1
+  INSERT INTO pgsz VALUES(1, eval('PRAGMA page_size'));
+--end
+--task 2
+  INSERT INTO pgsz VALUES(2, eval('PRAGMA page_size'));
+--end
+--task 3
+  INSERT INTO pgsz VALUES(3, eval('PRAGMA page_size'));
+--end
+--task 4
+  INSERT INTO pgsz VALUES(4, eval('PRAGMA page_size'));
+--end
+--task 5
+  INSERT INTO pgsz VALUES(5, eval('PRAGMA page_size'));
+--end
+--source multiwrite01.test
+--source crash02.subtest
+--wait all
+SELECT sz FROM pgsz;
+--match 1024 1024 1024 1024 1024
+PRAGMA page_size=2048;
+VACUUM;
+DELETE FROM pgsz;
+--task 1
+  INSERT INTO pgsz VALUES(1, eval('PRAGMA page_size'));
+--end
+--task 2
+  INSERT INTO pgsz VALUES(2, eval('PRAGMA page_size'));
+--end
+--task 3
+  INSERT INTO pgsz VALUES(3, eval('PRAGMA page_size'));
+--end
+--task 4
+  INSERT INTO pgsz VALUES(4, eval('PRAGMA page_size'));
+--end
+--task 5
+  INSERT INTO pgsz VALUES(5, eval('PRAGMA page_size'));
+--end
+--source multiwrite01.test
+--source crash02.subtest
+--wait all
+SELECT sz FROM pgsz;
+--match 2048 2048 2048 2048 2048
+PRAGMA page_size=8192;
+VACUUM;
+DELETE FROM pgsz;
+--task 1
+  INSERT INTO pgsz VALUES(1, eval('PRAGMA page_size'));
+--end
+--task 2
+  INSERT INTO pgsz VALUES(2, eval('PRAGMA page_size'));
+--end
+--task 3
+  INSERT INTO pgsz VALUES(3, eval('PRAGMA page_size'));
+--end
+--task 4
+  INSERT INTO pgsz VALUES(4, eval('PRAGMA page_size'));
+--end
+--task 5
+  INSERT INTO pgsz VALUES(5, eval('PRAGMA page_size'));
+--end
+--source multiwrite01.test
+--source crash02.subtest
+--wait all
+SELECT sz FROM pgsz;
+--match 8192 8192 8192 8192 8192
+PRAGMA page_size=16384;
+VACUUM;
+DELETE FROM pgsz;
+--task 1
+  INSERT INTO pgsz VALUES(1, eval('PRAGMA page_size'));
+--end
+--task 2
+  INSERT INTO pgsz VALUES(2, eval('PRAGMA page_size'));
+--end
+--task 3
+  INSERT INTO pgsz VALUES(3, eval('PRAGMA page_size'));
+--end
+--task 4
+  INSERT INTO pgsz VALUES(4, eval('PRAGMA page_size'));
+--end
+--task 5
+  INSERT INTO pgsz VALUES(5, eval('PRAGMA page_size'));
+--end
+--source multiwrite01.test
+--source crash02.subtest
+--wait all
+SELECT sz FROM pgsz;
+--match 16384 16384 16384 16384 16384
+PRAGMA auto_vacuum=FULL;
+VACUUM;
+--source multiwrite01.test
+--source crash02.subtest
+--wait all
+PRAGMA auto_vacuum=FULL;
+PRAGMA page_size=512;
+VACUUM;
+--source multiwrite01.test
+--source crash02.subtest

tests/mptest/testdata/crash01.test

@@ -0,0 +1,106 @@
+/* Test cases involving incomplete transactions that must be rolled back.
+*/
+--task 1
+  DROP TABLE IF EXISTS t1;
+  CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
+  --sleep 1
+  INSERT INTO t1 VALUES(1, randomblob(2000));
+  INSERT INTO t1 VALUES(2, randomblob(1000));
+  --sleep 1
+  INSERT INTO t1 SELECT a+2, randomblob(1500) FROM t1;
+  INSERT INTO t1 SELECT a+4, randomblob(1500) FROM t1;
+  INSERT INTO t1 SELECT a+8, randomblob(1500) FROM t1;
+  --sleep 1
+  INSERT INTO t1 SELECT a+16, randomblob(1500) FROM t1;
+  --sleep 1
+  INSERT INTO t1 SELECT a+32, randomblob(1500) FROM t1;
+  SELECT count(*) FROM t1;
+  --match 64
+  SELECT avg(length(b)) FROM t1;
+  --match 1500.0
+  --sleep 2
+  UPDATE t1 SET b='x'||a||'y';
+  SELECT sum(length(b)) FROM t1;
+  --match 247
+  SELECT a FROM t1 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t1b ON t1(b);
+  SELECT a FROM t1 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t1 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+--wait 1
+--task 2
+  DROP TABLE IF EXISTS t2;
+  CREATE TABLE t2(a INTEGER PRIMARY KEY, b);
+  INSERT INTO t2 SELECT a, b FROM t1;
+  UPDATE t1 SET b='x'||a||'y';
+  SELECT sum(length(b)) FROM t2;
+  --match 247
+  SELECT a FROM t2 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t2b ON t2(b);
+  SELECT a FROM t2 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t2 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+--task 3
+  DROP TABLE IF EXISTS t3;
+  CREATE TABLE t3(a INTEGER PRIMARY KEY, b);
+  INSERT INTO t3 SELECT a, b FROM t1;
+  UPDATE t1 SET b='x'||a||'y';
+  SELECT sum(length(b)) FROM t3;
+  --match 247
+  SELECT a FROM t3 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t3b ON t3(b);
+  SELECT a FROM t3 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t3 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+--task 4
+  DROP TABLE IF EXISTS t4;
+  CREATE TABLE t4(a INTEGER PRIMARY KEY, b);
+  INSERT INTO t4 SELECT a, b FROM t1;
+  UPDATE t1 SET b='x'||a||'y';
+  SELECT sum(length(b)) FROM t4;
+  --match 247
+  SELECT a FROM t4 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t4b ON t4(b);
+  SELECT a FROM t4 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t4 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+--task 5
+  DROP TABLE IF EXISTS t5;
+  CREATE TABLE t5(a INTEGER PRIMARY KEY, b);
+  INSERT INTO t5 SELECT a, b FROM t1;
+  UPDATE t1 SET b='x'||a||'y';
+  SELECT sum(length(b)) FROM t5;
+  --match 247
+  SELECT a FROM t5 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t5b ON t5(b);
+  SELECT a FROM t5 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t5 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+
+--wait all
+/* After the database file has been set up, run the crash2 subscript
+** multiple times. */
+--source crash02.subtest
+--source crash02.subtest
+--source crash02.subtest
+--source crash02.subtest
+--source crash02.subtest
+--source crash02.subtest
+--source crash02.subtest
+--source crash02.subtest
+--source crash02.subtest

tests/mptest/testdata/crash02.subtest

@@ -0,0 +1,53 @@
+/*
+** This script is called from crash01.test and config02.test and perhaps other
+** script.  After the database file has been set up, make a big rollback 
+** journal in client 1, then crash client 1.
+** Then in the other clients, do an integrity check.
+*/
+--task 1 leave-hot-journal
+  --sleep 5
+  --finish
+  PRAGMA cache_size=10;
+  BEGIN;
+  UPDATE t1 SET b=randomblob(20000);
+  UPDATE t2 SET b=randomblob(20000);
+  UPDATE t3 SET b=randomblob(20000);
+  UPDATE t4 SET b=randomblob(20000);
+  UPDATE t5 SET b=randomblob(20000);
+  UPDATE t1 SET b=NULL;
+  UPDATE t2 SET b=NULL;
+  UPDATE t3 SET b=NULL;
+  UPDATE t4 SET b=NULL;
+  UPDATE t5 SET b=NULL;
+  --print Task one crashing an incomplete transaction
+  --exit 1
+--end
+--task 2 integrity_check-2
+  SELECT count(*) FROM t1;
+  --match 64
+  --sleep 100
+  PRAGMA integrity_check(10);
+  --match ok
+--end
+--task 3 integrity_check-3
+  SELECT count(*) FROM t1;
+  --match 64
+  --sleep 100
+  PRAGMA integrity_check(10);
+  --match ok
+--end
+--task 4 integrity_check-4
+  SELECT count(*) FROM t1;
+  --match 64
+  --sleep 100
+  PRAGMA integrity_check(10);
+  --match ok
+--end
+--task 5 integrity_check-5
+  SELECT count(*) FROM t1;
+  --match 64
+  --sleep 100
+  PRAGMA integrity_check(10);
+  --match ok
+--end
+--wait all

tests/mptest/testdata/main.c

@@ -0,0 +1,22 @@
+#include <stdbool.h>
+#include <stddef.h>
+
+#include "os.c"
+#include "qsort.c"
+#include "sqlite3.c"
+
+sqlite3_destructor_type malloc_destructor = &free;
+size_t sqlite3_interrupt_offset = offsetof(sqlite3, u1.isInterrupted);
+
+void __attribute__((constructor)) premain() { sqlite3_initialize(); }
+
+int sqlite3_enable_load_extension(sqlite3 *db, int onoff) { return SQLITE_OK; }
+
+void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void *, const char *),
+                    void *pArg) {
+  return NULL;
+}
+
+int sqlite3_os_init() {
+  return sqlite3_vfs_register(os_vfs(), /*default=*/true);
+}

tests/mptest/testdata/mptest.wasm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3960b873a7dab969a66f7859d491cec0dd4e6c0c9f83eab449fb15ec5ebdfd8f
+size 1077281

tests/mptest/testdata/multiwrite01.test

@@ -0,0 +1,415 @@
+/*
+** This script sets up five different tasks all writing and updating
+** the database at the same time, but each in its own table.
+*/
+--task 1 build-t1
+  DROP TABLE IF EXISTS t1;
+  CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
+  --sleep 1
+  INSERT INTO t1 VALUES(1, randomblob(2000));
+  INSERT INTO t1 VALUES(2, randomblob(1000));
+  --sleep 1
+  INSERT INTO t1 SELECT a+2, randomblob(1500) FROM t1;
+  INSERT INTO t1 SELECT a+4, randomblob(1500) FROM t1;
+  INSERT INTO t1 SELECT a+8, randomblob(1500) FROM t1;
+  --sleep 1
+  INSERT INTO t1 SELECT a+16, randomblob(1500) FROM t1;
+  --sleep 1
+  INSERT INTO t1 SELECT a+32, randomblob(1500) FROM t1;
+  SELECT count(*) FROM t1;
+  --match 64
+  SELECT avg(length(b)) FROM t1;
+  --match 1500.0
+  --sleep 2
+  UPDATE t1 SET b='x'||a||'y';
+  SELECT sum(length(b)) FROM t1;
+  --match 247
+  SELECT a FROM t1 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t1b ON t1(b);
+  SELECT a FROM t1 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t1 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+
+
+--task 2 build-t2
+  DROP TABLE IF EXISTS t2;
+  CREATE TABLE t2(a INTEGER PRIMARY KEY, b);
+  --sleep 1
+  INSERT INTO t2 VALUES(1, randomblob(2000));
+  INSERT INTO t2 VALUES(2, randomblob(1000));
+  --sleep 1
+  INSERT INTO t2 SELECT a+2, randomblob(1500) FROM t2;
+  INSERT INTO t2 SELECT a+4, randomblob(1500) FROM t2;
+  INSERT INTO t2 SELECT a+8, randomblob(1500) FROM t2;
+  --sleep 1
+  INSERT INTO t2 SELECT a+16, randomblob(1500) FROM t2;
+  --sleep 1
+  INSERT INTO t2 SELECT a+32, randomblob(1500) FROM t2;
+  SELECT count(*) FROM t2;
+  --match 64
+  SELECT avg(length(b)) FROM t2;
+  --match 1500.0
+  --sleep 2
+  UPDATE t2 SET b='x'||a||'y';
+  SELECT sum(length(b)) FROM t2;
+  --match 247
+  SELECT a FROM t2 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t2b ON t2(b);
+  SELECT a FROM t2 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t2 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+
+--task 3 build-t3
+  DROP TABLE IF EXISTS t3;
+  CREATE TABLE t3(a INTEGER PRIMARY KEY, b);
+  --sleep 1
+  INSERT INTO t3 VALUES(1, randomblob(2000));
+  INSERT INTO t3 VALUES(2, randomblob(1000));
+  --sleep 1
+  INSERT INTO t3 SELECT a+2, randomblob(1500) FROM t3;
+  INSERT INTO t3 SELECT a+4, randomblob(1500) FROM t3;
+  INSERT INTO t3 SELECT a+8, randomblob(1500) FROM t3;
+  --sleep 1
+  INSERT INTO t3 SELECT a+16, randomblob(1500) FROM t3;
+  --sleep 1
+  INSERT INTO t3 SELECT a+32, randomblob(1500) FROM t3;
+  SELECT count(*) FROM t3;
+  --match 64
+  SELECT avg(length(b)) FROM t3;
+  --match 1500.0
+  --sleep 2
+  UPDATE t3 SET b='x'||a||'y';
+  SELECT sum(length(b)) FROM t3;
+  --match 247
+  SELECT a FROM t3 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t3b ON t3(b);
+  SELECT a FROM t3 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t3 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+
+--task 4 build-t4
+  DROP TABLE IF EXISTS t4;
+  CREATE TABLE t4(a INTEGER PRIMARY KEY, b);
+  --sleep 1
+  INSERT INTO t4 VALUES(1, randomblob(2000));
+  INSERT INTO t4 VALUES(2, randomblob(1000));
+  --sleep 1
+  INSERT INTO t4 SELECT a+2, randomblob(1500) FROM t4;
+  INSERT INTO t4 SELECT a+4, randomblob(1500) FROM t4;
+  INSERT INTO t4 SELECT a+8, randomblob(1500) FROM t4;
+  --sleep 1
+  INSERT INTO t4 SELECT a+16, randomblob(1500) FROM t4;
+  --sleep 1
+  INSERT INTO t4 SELECT a+32, randomblob(1500) FROM t4;
+  SELECT count(*) FROM t4;
+  --match 64
+  SELECT avg(length(b)) FROM t4;
+  --match 1500.0
+  --sleep 2
+  UPDATE t4 SET b='x'||a||'y';
+  SELECT sum(length(b)) FROM t4;
+  --match 247
+  SELECT a FROM t4 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t4b ON t4(b);
+  SELECT a FROM t4 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t4 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+
+--task 5 build-t5
+  DROP TABLE IF EXISTS t5;
+  CREATE TABLE t5(a INTEGER PRIMARY KEY, b);
+  --sleep 1
+  INSERT INTO t5 VALUES(1, randomblob(2000));
+  INSERT INTO t5 VALUES(2, randomblob(1000));
+  --sleep 1
+  INSERT INTO t5 SELECT a+2, randomblob(1500) FROM t5;
+  INSERT INTO t5 SELECT a+4, randomblob(1500) FROM t5;
+  INSERT INTO t5 SELECT a+8, randomblob(1500) FROM t5;
+  --sleep 1
+  INSERT INTO t5 SELECT a+16, randomblob(1500) FROM t5;
+  --sleep 1
+  INSERT INTO t5 SELECT a+32, randomblob(1500) FROM t5;
+  SELECT count(*) FROM t5;
+  --match 64
+  SELECT avg(length(b)) FROM t5;
+  --match 1500.0
+  --sleep 2
+  UPDATE t5 SET b='x'||a||'y';
+  SELECT sum(length(b)) FROM t5;
+  --match 247
+  SELECT a FROM t5 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t5b ON t5(b);
+  SELECT a FROM t5 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t5 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+
+--wait all
+SELECT count(*), sum(length(b)) FROM t1;
+--match 64 247
+SELECT count(*), sum(length(b)) FROM t2;
+--match 64 247
+SELECT count(*), sum(length(b)) FROM t3;
+--match 64 247
+SELECT count(*), sum(length(b)) FROM t4;
+--match 64 247
+SELECT count(*), sum(length(b)) FROM t5;
+--match 64 247
+
+--task 1
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 5
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 3
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 2
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 4
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--wait all
+
+--task 5
+  DROP INDEX t5b;
+  --sleep 5
+  PRAGMA integrity_check(10);
+  --match ok
+  CREATE INDEX t5b ON t5(b DESC);
+--end
+--task 3
+  DROP INDEX t3b;
+  --sleep 5
+  PRAGMA integrity_check(10);
+  --match ok
+  CREATE INDEX t3b ON t3(b DESC);
+--end
+--task 1
+  DROP INDEX t1b;
+  --sleep 5
+  PRAGMA integrity_check(10);
+  --match ok
+  CREATE INDEX t1b ON t1(b DESC);
+--end
+--task 2
+  DROP INDEX t2b;
+  --sleep 5
+  PRAGMA integrity_check(10);
+  --match ok
+  CREATE INDEX t2b ON t2(b DESC);
+--end
+--task 4
+  DROP INDEX t4b;
+  --sleep 5
+  PRAGMA integrity_check(10);
+  --match ok
+  CREATE INDEX t4b ON t4(b DESC);
+--end
+--wait all
+
+--task 1
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 5
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 3
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 2
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 4
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--wait all
+
+VACUUM;
+PRAGMA integrity_check(10);
+--match ok
+
+--task 1
+  UPDATE t1 SET b=randomblob(20000);
+  --sleep 5
+  UPDATE t1 SET b='x'||a||'y';
+  SELECT a FROM t1 WHERE b='x63y';
+  --match 63
+--end
+--task 2
+  UPDATE t2 SET b=randomblob(20000);
+  --sleep 5
+  UPDATE t2 SET b='x'||a||'y';
+  SELECT a FROM t2 WHERE b='x63y';
+  --match 63
+--end
+--task 3
+  UPDATE t3 SET b=randomblob(20000);
+  --sleep 5
+  UPDATE t3 SET b='x'||a||'y';
+  SELECT a FROM t3 WHERE b='x63y';
+  --match 63
+--end
+--task 4
+  UPDATE t4 SET b=randomblob(20000);
+  --sleep 5
+  UPDATE t4 SET b='x'||a||'y';
+  SELECT a FROM t4 WHERE b='x63y';
+  --match 63
+--end
+--task 5
+  UPDATE t5 SET b=randomblob(20000);
+  --sleep 5
+  UPDATE t5 SET b='x'||a||'y';
+  SELECT a FROM t5 WHERE b='x63y';
+  --match 63
+--end
+--wait all
+
+--task 1
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+  PRAGMA integrity_check;
+  --match ok
+--end
+--task 5
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+  PRAGMA integrity_check;
+  --match ok
+--end
+--task 3
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+  PRAGMA integrity_check;
+  --match ok
+--end
+--task 2
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+  PRAGMA integrity_check;
+  --match ok
+--end
+--task 4
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+  PRAGMA integrity_check;
+  --match ok
+--end
+--wait all

tests/mptest/testdata/test.c

@@ -0,0 +1,5 @@
+#define unlink dont_unlink
+
+#include "mptest.c"
+
+int dont_unlink(const char *pathname) { return 0; }

tests/parallel/parallel_test.go

@@ -14,8 +14,15 @@ import (
 )
 
 func TestParallel(t *testing.T) {
+	var iter int
+	if testing.Short() {
+		iter = 1000
+	} else {
+		iter = 5000
+	}
+
 	name := filepath.Join(t.TempDir(), "test.db")
-	testParallel(t, name, 1000)
+	testParallel(t, name, iter)
 	testIntegrity(t, name)
 }
 
@@ -135,7 +142,7 @@ func testParallel(t *testing.T, name string, n int) {
 	}
 
 	var group errgroup.Group
-	group.SetLimit(4)
+	group.SetLimit(6)
 	for i := 0; i < n; i++ {
 		if i&7 != 7 {
 			group.Go(reader)

tests/time_test.go

@@ -0,0 +1,120 @@
+package tests
+
+import (
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+func TestTimeFormat_Encode(t *testing.T) {
+	t.Parallel()
+
+	reference := time.Date(2013, 10, 7, 4, 23, 19, 120_000_000, time.FixedZone("", -4*3600))
+
+	tests := []struct {
+		fmt  sqlite3.TimeFormat
+		time time.Time
+		want any
+	}{
+		{sqlite3.TimeFormatDefault, reference, "2013-10-07T04:23:19.12-04:00"},
+		{sqlite3.TimeFormatJulianDay, reference, 2456572.849526851851852},
+		{sqlite3.TimeFormatUnix, reference, int64(1381134199)},
+		{sqlite3.TimeFormatUnixFrac, reference, 1381134199.120},
+		{sqlite3.TimeFormatUnixMilli, reference, int64(1381134199_120)},
+		{sqlite3.TimeFormatUnixMicro, reference, int64(1381134199_120000)},
+		{sqlite3.TimeFormatUnixNano, reference, int64(1381134199_120000000)},
+		{sqlite3.TimeFormat7, reference, "2013-10-07T08:23:19.120"},
+	}
+	for _, tt := range tests {
+		t.Run("", func(t *testing.T) {
+			if got := tt.fmt.Encode(tt.time); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("%q.Encode(%v) = %v, want %v", tt.fmt, tt.time, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestTimeFormat_Decode(t *testing.T) {
+	t.Parallel()
+
+	reference := time.Date(2013, 10, 7, 4, 23, 19, 120_000_000, time.FixedZone("", -4*3600))
+	reftime := time.Date(2000, 1, 1, 4, 23, 19, 120_000_000, time.FixedZone("", -4*3600))
+
+	tests := []struct {
+		fmt       sqlite3.TimeFormat
+		val       any
+		want      time.Time
+		wantDelta time.Duration
+		wantErr   bool
+	}{
+		{sqlite3.TimeFormatJulianDay, "2456572.849526851851852", reference, 0, false},
+		{sqlite3.TimeFormatJulianDay, 2456572.849526851851852, reference, time.Millisecond, false},
+		{sqlite3.TimeFormatJulianDay, int64(2456572), reference, 24 * time.Hour, false},
+		{sqlite3.TimeFormatJulianDay, false, time.Time{}, 0, true},
+
+		{sqlite3.TimeFormatUnix, "1381134199.120", reference, time.Microsecond, false},
+		{sqlite3.TimeFormatUnix, 1381134199.120, reference, time.Microsecond, false},
+		{sqlite3.TimeFormatUnix, int64(1381134199), reference, time.Second, false},
+		{sqlite3.TimeFormatUnix, "abc", time.Time{}, 0, true},
+		{sqlite3.TimeFormatUnix, false, time.Time{}, 0, true},
+
+		{sqlite3.TimeFormatUnixMilli, "1381134199120", reference, 0, false},
+		{sqlite3.TimeFormatUnixMilli, 1381134199.120e3, reference, 0, false},
+		{sqlite3.TimeFormatUnixMilli, int64(1381134199_120), reference, 0, false},
+		{sqlite3.TimeFormatUnixMilli, "abc", time.Time{}, 0, true},
+		{sqlite3.TimeFormatUnixMilli, false, time.Time{}, 0, true},
+
+		{sqlite3.TimeFormatUnixMicro, "1381134199120000", reference, 0, false},
+		{sqlite3.TimeFormatUnixMicro, 1381134199.120e6, reference, 0, false},
+		{sqlite3.TimeFormatUnixMicro, int64(1381134199_120000), reference, 0, false},
+		{sqlite3.TimeFormatUnixMicro, "abc", time.Time{}, 0, true},
+		{sqlite3.TimeFormatUnixMicro, false, time.Time{}, 0, true},
+
+		{sqlite3.TimeFormatUnixNano, "1381134199120000000", reference, 0, false},
+		{sqlite3.TimeFormatUnixNano, 1381134199.120e9, reference, 0, false},
+		{sqlite3.TimeFormatUnixNano, int64(1381134199_120000000), reference, 0, false},
+		{sqlite3.TimeFormatUnixNano, "abc", time.Time{}, 0, true},
+		{sqlite3.TimeFormatUnixNano, false, time.Time{}, 0, true},
+
+		{sqlite3.TimeFormatAuto, "2456572.849526851851852", reference, time.Millisecond, false},
+		{sqlite3.TimeFormatAuto, "2456572", reference, 24 * time.Hour, false},
+		{sqlite3.TimeFormatAuto, "1381134199.120", reference, time.Microsecond, false},
+		{sqlite3.TimeFormatAuto, "1381134199.120e3", reference, time.Microsecond, false},
+		{sqlite3.TimeFormatAuto, "1381134199.120e6", reference, time.Microsecond, false},
+		{sqlite3.TimeFormatAuto, "1381134199.120e9", reference, time.Microsecond, false},
+		{sqlite3.TimeFormatAuto, "1381134199", reference, time.Second, false},
+		{sqlite3.TimeFormatAuto, "1381134199120", reference, 0, false},
+		{sqlite3.TimeFormatAuto, "1381134199120000", reference, 0, false},
+		{sqlite3.TimeFormatAuto, "1381134199120000000", reference, 0, false},
+		{sqlite3.TimeFormatAuto, "2013-10-07 04:23:19.12-04:00", reference, 0, false},
+		{sqlite3.TimeFormatAuto, "04:23:19.12-04:00", reftime, 0, false},
+		{sqlite3.TimeFormatAuto, "abc", time.Time{}, 0, true},
+		{sqlite3.TimeFormatAuto, false, time.Time{}, 0, true},
+
+		{sqlite3.TimeFormat3, "2013-10-07 04:23:19.12-04:00", reference, 0, false},
+		{sqlite3.TimeFormat3, "2013-10-07 08:23:19.12", reference, 0, false},
+		{sqlite3.TimeFormat9, "04:23:19.12-04:00", reftime, 0, false},
+		{sqlite3.TimeFormat9, "08:23:19.12", reftime, 0, false},
+		{sqlite3.TimeFormat3, false, time.Time{}, 0, true},
+		{sqlite3.TimeFormat9, false, time.Time{}, 0, true},
+
+		{sqlite3.TimeFormatDefault, "2013-10-07T04:23:19.12-04:00", reference, 0, false},
+		{sqlite3.TimeFormatDefault, "2013-10-07T08:23:19.12Z", reference, 0, false},
+		{sqlite3.TimeFormatDefault, false, time.Time{}, 0, true},
+	}
+
+	for _, tt := range tests {
+		t.Run("", func(t *testing.T) {
+			got, err := tt.fmt.Decode(tt.val)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("%q.Decode(%v) error = %v, wantErr %v", tt.fmt, tt.val, err, tt.wantErr)
+				return
+			}
+			if tt.want.Sub(got).Abs() > tt.wantDelta {
+				t.Errorf("%q.Decode(%v) = %v, want %v", tt.fmt, tt.val, got, tt.want)
+			}
+		})
+	}
+}

tests/tx_test.go

@@ -29,6 +29,7 @@ func TestConn_Transaction_exec(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
+		defer stmt.Close()
 		if stmt.Step() {
 			return stmt.ColumnInt(0)
 		}
@@ -117,6 +118,7 @@ func TestConn_Transaction_panic(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
+		defer stmt.Close()
 		if stmt.Step() {
 			got := stmt.ColumnInt(0)
 			if got != 1 {
@@ -275,6 +277,7 @@ func TestConn_Savepoint_exec(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
+		defer stmt.Close()
 		if stmt.Step() {
 			return stmt.ColumnInt(0)
 		}
@@ -361,6 +364,7 @@ func TestConn_Savepoint_panic(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
+		defer stmt.Close()
 		if stmt.Step() {
 			got := stmt.ColumnInt(0)
 			if got != 1 {

tests/type_test.go

@@ -1,19 +1,23 @@
-package sqlite3
+package tests
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+)
 
 func TestDatatype_String(t *testing.T) {
 	t.Parallel()
 
 	tests := []struct {
-		data Datatype
+		data sqlite3.Datatype
 		want string
 	}{
-		{INTEGER, "INTEGER"},
-		{FLOAT, "FLOAT"},
-		{TEXT, "TEXT"},
-		{BLOB, "BLOB"},
-		{NULL, "NULL"},
+		{sqlite3.INTEGER, "INTEGER"},
+		{sqlite3.FLOAT, "FLOAT"},
+		{sqlite3.TEXT, "TEXT"},
+		{sqlite3.BLOB, "BLOB"},
+		{sqlite3.NULL, "NULL"},
 		{10, "10"},
 	}
 	for _, tt := range tests {

time_test.go

@@ -1,118 +0,0 @@
-package sqlite3
-
-import (
-	"reflect"
-	"testing"
-	"time"
-)
-
-func TestTimeFormat_Encode(t *testing.T) {
-	t.Parallel()
-
-	reference := time.Date(2013, 10, 7, 4, 23, 19, 120_000_000, time.FixedZone("", -4*3600))
-
-	tests := []struct {
-		fmt  TimeFormat
-		time time.Time
-		want any
-	}{
-		{TimeFormatDefault, reference, "2013-10-07T04:23:19.12-04:00"},
-		{TimeFormatJulianDay, reference, 2456572.849526851851852},
-		{TimeFormatUnix, reference, int64(1381134199)},
-		{TimeFormatUnixFrac, reference, 1381134199.120},
-		{TimeFormatUnixMilli, reference, int64(1381134199_120)},
-		{TimeFormatUnixMicro, reference, int64(1381134199_120000)},
-		{TimeFormatUnixNano, reference, int64(1381134199_120000000)},
-		{TimeFormat7, reference, "2013-10-07T08:23:19.120"},
-	}
-	for _, tt := range tests {
-		t.Run("", func(t *testing.T) {
-			if got := tt.fmt.Encode(tt.time); !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("%q.Encode(%v) = %v, want %v", tt.fmt, tt.time, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestTimeFormat_Decode(t *testing.T) {
-	t.Parallel()
-
-	reference := time.Date(2013, 10, 7, 4, 23, 19, 120_000_000, time.FixedZone("", -4*3600))
-	reftime := time.Date(2000, 1, 1, 4, 23, 19, 120_000_000, time.FixedZone("", -4*3600))
-
-	tests := []struct {
-		fmt       TimeFormat
-		val       any
-		want      time.Time
-		wantDelta time.Duration
-		wantErr   bool
-	}{
-		{TimeFormatJulianDay, "2456572.849526851851852", reference, 0, false},
-		{TimeFormatJulianDay, 2456572.849526851851852, reference, time.Millisecond, false},
-		{TimeFormatJulianDay, int64(2456572), reference, 24 * time.Hour, false},
-		{TimeFormatJulianDay, false, time.Time{}, 0, true},
-
-		{TimeFormatUnix, "1381134199.120", reference, time.Microsecond, false},
-		{TimeFormatUnix, 1381134199.120, reference, time.Microsecond, false},
-		{TimeFormatUnix, int64(1381134199), reference, time.Second, false},
-		{TimeFormatUnix, "abc", time.Time{}, 0, true},
-		{TimeFormatUnix, false, time.Time{}, 0, true},
-
-		{TimeFormatUnixMilli, "1381134199120", reference, 0, false},
-		{TimeFormatUnixMilli, 1381134199.120e3, reference, 0, false},
-		{TimeFormatUnixMilli, int64(1381134199_120), reference, 0, false},
-		{TimeFormatUnixMilli, "abc", time.Time{}, 0, true},
-		{TimeFormatUnixMilli, false, time.Time{}, 0, true},
-
-		{TimeFormatUnixMicro, "1381134199120000", reference, 0, false},
-		{TimeFormatUnixMicro, 1381134199.120e6, reference, 0, false},
-		{TimeFormatUnixMicro, int64(1381134199_120000), reference, 0, false},
-		{TimeFormatUnixMicro, "abc", time.Time{}, 0, true},
-		{TimeFormatUnixMicro, false, time.Time{}, 0, true},
-
-		{TimeFormatUnixNano, "1381134199120000000", reference, 0, false},
-		{TimeFormatUnixNano, 1381134199.120e9, reference, 0, false},
-		{TimeFormatUnixNano, int64(1381134199_120000000), reference, 0, false},
-		{TimeFormatUnixNano, "abc", time.Time{}, 0, true},
-		{TimeFormatUnixNano, false, time.Time{}, 0, true},
-
-		{TimeFormatAuto, "2456572.849526851851852", reference, time.Millisecond, false},
-		{TimeFormatAuto, "2456572", reference, 24 * time.Hour, false},
-		{TimeFormatAuto, "1381134199.120", reference, time.Microsecond, false},
-		{TimeFormatAuto, "1381134199.120e3", reference, time.Microsecond, false},
-		{TimeFormatAuto, "1381134199.120e6", reference, time.Microsecond, false},
-		{TimeFormatAuto, "1381134199.120e9", reference, time.Microsecond, false},
-		{TimeFormatAuto, "1381134199", reference, time.Second, false},
-		{TimeFormatAuto, "1381134199120", reference, 0, false},
-		{TimeFormatAuto, "1381134199120000", reference, 0, false},
-		{TimeFormatAuto, "1381134199120000000", reference, 0, false},
-		{TimeFormatAuto, "2013-10-07 04:23:19.12-04:00", reference, 0, false},
-		{TimeFormatAuto, "04:23:19.12-04:00", reftime, 0, false},
-		{TimeFormatAuto, "abc", time.Time{}, 0, true},
-		{TimeFormatAuto, false, time.Time{}, 0, true},
-
-		{TimeFormat3, "2013-10-07 04:23:19.12-04:00", reference, 0, false},
-		{TimeFormat3, "2013-10-07 08:23:19.12", reference, 0, false},
-		{TimeFormat9, "04:23:19.12-04:00", reftime, 0, false},
-		{TimeFormat9, "08:23:19.12", reftime, 0, false},
-		{TimeFormat3, false, time.Time{}, 0, true},
-		{TimeFormat9, false, time.Time{}, 0, true},
-
-		{TimeFormatDefault, "2013-10-07T04:23:19.12-04:00", reference, 0, false},
-		{TimeFormatDefault, "2013-10-07T08:23:19.12Z", reference, 0, false},
-		{TimeFormatDefault, false, time.Time{}, 0, true},
-	}
-
-	for _, tt := range tests {
-		t.Run("", func(t *testing.T) {
-			got, err := tt.fmt.Decode(tt.val)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("%q.Decode(%v) error = %v, wantErr %v", tt.fmt, tt.val, err, tt.wantErr)
-				return
-			}
-			if tt.want.Sub(got).Abs() > tt.wantDelta {
-				t.Errorf("%q.Decode(%v) = %v, want %v", tt.fmt, tt.val, got, tt.want)
-			}
-		})
-	}
-}

tx.go

@@ -7,6 +7,7 @@ import (
 	"runtime"
 )
 
+// Tx is an in-progress database transaction.
 type Tx struct {
 	c *Conn
 }

vfs.go

@@ -26,6 +26,14 @@ func vfsInstantiate(ctx context.Context, r wazero.Runtime) {
 		panic(err)
 	}
 
+	env := vfsNewEnvModuleBuilder(r)
+	_, err = env.Instantiate(ctx)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func vfsNewEnvModuleBuilder(r wazero.Runtime) wazero.HostModuleBuilder {
 	env := r.NewHostModuleBuilder("env")
 	env.NewFunctionBuilder().WithFunc(vfsLocaltime).Export("os_localtime")
 	env.NewFunctionBuilder().WithFunc(vfsRandomness).Export("os_randomness")
@@ -46,15 +54,39 @@ func vfsInstantiate(ctx context.Context, r wazero.Runtime) {
 	env.NewFunctionBuilder().WithFunc(vfsUnlock).Export("os_unlock")
 	env.NewFunctionBuilder().WithFunc(vfsCheckReservedLock).Export("os_check_reserved_lock")
 	env.NewFunctionBuilder().WithFunc(vfsFileControl).Export("os_file_control")
-	_, err = env.Instantiate(ctx)
-	if err != nil {
-		panic(err)
-	}
+	return env
 }
 
-type vfsOSMethods bool
+// Poor man's namespaces.
+const (
+	vfsOS   vfsOSMethods   = false
+	vfsFile vfsFileMethods = false
+)
 
-const vfsOS vfsOSMethods = false
+type (
+	vfsOSMethods   bool
+	vfsFileMethods bool
+)
+
+type vfsKey struct{}
+type vfsState struct {
+	files []*os.File
+}
+
+func vfsContext(ctx context.Context) (context.Context, io.Closer) {
+	vfs := &vfsState{}
+	return context.WithValue(ctx, vfsKey{}, vfs), vfs
+}
+
+func (vfs *vfsState) Close() error {
+	for _, f := range vfs.files {
+		if f != nil {
+			f.Close()
+		}
+	}
+	vfs.files = nil
+	return nil
+}
 
 func vfsExit(ctx context.Context, mod api.Module, exitCode uint32) {
 	// Ensure other callers see the exit code.
@@ -227,8 +259,7 @@ func vfsOpen(ctx context.Context, mod api.Module, pVfs, zName, pFile uint32, fla
 		vfsOS.DeleteOnClose(file)
 	}
 
-	id := vfsGetFileID(file)
-	vfsFilePtr{mod, pFile}.SetID(id).SetLock(_NO_LOCK)
+	vfsFile.Open(ctx, mod, pFile, file)
 
 	if pOutFlags != 0 {
 		memory{mod}.writeUint32(pOutFlags, uint32(flags))
@@ -237,8 +268,7 @@ func vfsOpen(ctx context.Context, mod api.Module, pVfs, zName, pFile uint32, fla
 }
 
 func vfsClose(ctx context.Context, mod api.Module, pFile uint32) uint32 {
-	id := vfsFilePtr{mod, pFile}.ID()
-	err := vfsCloseFile(id)
+	err := vfsFile.Close(ctx, mod, pFile)
 	if err != nil {
 		return uint32(IOERR_CLOSE)
 	}
@@ -248,7 +278,7 @@ func vfsClose(ctx context.Context, mod api.Module, pFile uint32) uint32 {
 func vfsRead(ctx context.Context, mod api.Module, pFile, zBuf, iAmt uint32, iOfst uint64) uint32 {
 	buf := memory{mod}.view(zBuf, uint64(iAmt))
 
-	file := vfsFilePtr{mod, pFile}.OSFile()
+	file := vfsFile.GetOS(ctx, mod, pFile)
 	n, err := file.ReadAt(buf, int64(iOfst))
 	if n == int(iAmt) {
 		return _OK
@@ -265,7 +295,7 @@ func vfsRead(ctx context.Context, mod api.Module, pFile, zBuf, iAmt uint32, iOfs
 func vfsWrite(ctx context.Context, mod api.Module, pFile, zBuf, iAmt uint32, iOfst uint64) uint32 {
 	buf := memory{mod}.view(zBuf, uint64(iAmt))
 
-	file := vfsFilePtr{mod, pFile}.OSFile()
+	file := vfsFile.GetOS(ctx, mod, pFile)
 	_, err := file.WriteAt(buf, int64(iOfst))
 	if err != nil {
 		return uint32(IOERR_WRITE)
@@ -274,7 +304,7 @@ func vfsWrite(ctx context.Context, mod api.Module, pFile, zBuf, iAmt uint32, iOf
 }
 
 func vfsTruncate(ctx context.Context, mod api.Module, pFile uint32, nByte uint64) uint32 {
-	file := vfsFilePtr{mod, pFile}.OSFile()
+	file := vfsFile.GetOS(ctx, mod, pFile)
 	err := file.Truncate(int64(nByte))
 	if err != nil {
 		return uint32(IOERR_TRUNCATE)
@@ -283,7 +313,7 @@ func vfsTruncate(ctx context.Context, mod api.Module, pFile uint32, nByte uint64
 }
 
 func vfsSync(ctx context.Context, mod api.Module, pFile, flags uint32) uint32 {
-	file := vfsFilePtr{mod, pFile}.OSFile()
+	file := vfsFile.GetOS(ctx, mod, pFile)
 	err := file.Sync()
 	if err != nil {
 		return uint32(IOERR_FSYNC)
@@ -295,7 +325,7 @@ func vfsFileSize(ctx context.Context, mod api.Module, pFile, pSize uint32) uint3
 	// This uses [os.File.Seek] because we don't care about the offset for reading/writing.
 	// But consider using [os.File.Stat] instead (as other VFSes do).
 
-	file := vfsFilePtr{mod, pFile}.OSFile()
+	file := vfsFile.GetOS(ctx, mod, pFile)
 	off, err := file.Seek(0, io.SeekEnd)
 	if err != nil {
 		return uint32(IOERR_SEEK)

vfs_file.go

@@ -0,0 +1,57 @@
+package sqlite3
+
+import (
+	"context"
+	"os"
+
+	"github.com/tetratelabs/wazero/api"
+)
+
+func (vfsFileMethods) NewID(ctx context.Context, file *os.File) uint32 {
+	vfs := ctx.Value(vfsKey{}).(*vfsState)
+
+	// Find an empty slot.
+	for id, ptr := range vfs.files {
+		if ptr == nil {
+			vfs.files[id] = file
+			return uint32(id)
+		}
+	}
+
+	// Add a new slot.
+	vfs.files = append(vfs.files, file)
+	return uint32(len(vfs.files) - 1)
+}
+
+func (vfsFileMethods) Open(ctx context.Context, mod api.Module, pFile uint32, file *os.File) {
+	mem := memory{mod}
+	id := vfsFile.NewID(ctx, file)
+	mem.writeUint32(pFile+ptrlen, id)
+	mem.writeUint32(pFile+2*ptrlen, _NO_LOCK)
+}
+
+func (vfsFileMethods) Close(ctx context.Context, mod api.Module, pFile uint32) error {
+	mem := memory{mod}
+	id := mem.readUint32(pFile + ptrlen)
+	vfs := ctx.Value(vfsKey{}).(*vfsState)
+	file := vfs.files[id]
+	vfs.files[id] = nil
+	return file.Close()
+}
+
+func (vfsFileMethods) GetOS(ctx context.Context, mod api.Module, pFile uint32) *os.File {
+	mem := memory{mod}
+	id := mem.readUint32(pFile + ptrlen)
+	vfs := ctx.Value(vfsKey{}).(*vfsState)
+	return vfs.files[id]
+}
+
+func (vfsFileMethods) GetLock(ctx context.Context, mod api.Module, pFile uint32) vfsLockState {
+	mem := memory{mod}
+	return vfsLockState(mem.readUint32(pFile + 2*ptrlen))
+}
+
+func (vfsFileMethods) SetLock(ctx context.Context, mod api.Module, pFile uint32, lock vfsLockState) {
+	mem := memory{mod}
+	mem.writeUint32(pFile+2*ptrlen, uint32(lock))
+}

vfs_files.go

@@ -1,69 +0,0 @@
-package sqlite3
-
-import (
-	"os"
-	"sync"
-
-	"github.com/tetratelabs/wazero/api"
-)
-
-var (
-	vfsOpenFiles    []*os.File
-	vfsOpenFilesMtx sync.Mutex
-)
-
-func vfsGetFileID(file *os.File) uint32 {
-	vfsOpenFilesMtx.Lock()
-	defer vfsOpenFilesMtx.Unlock()
-
-	// Find an empty slot.
-	for id, ptr := range vfsOpenFiles {
-		if ptr == nil {
-			vfsOpenFiles[id] = file
-			return uint32(id)
-		}
-	}
-
-	// Add a new slot.
-	vfsOpenFiles = append(vfsOpenFiles, file)
-	return uint32(len(vfsOpenFiles) - 1)
-}
-
-func vfsCloseFile(id uint32) error {
-	vfsOpenFilesMtx.Lock()
-	defer vfsOpenFilesMtx.Unlock()
-
-	file := vfsOpenFiles[id]
-	vfsOpenFiles[id] = nil
-	return file.Close()
-}
-
-type vfsFilePtr struct {
-	api.Module
-	ptr uint32
-}
-
-func (p vfsFilePtr) OSFile() *os.File {
-	id := p.ID()
-	vfsOpenFilesMtx.Lock()
-	defer vfsOpenFilesMtx.Unlock()
-	return vfsOpenFiles[id]
-}
-
-func (p vfsFilePtr) ID() uint32 {
-	return memory{p}.readUint32(p.ptr + ptrlen)
-}
-
-func (p vfsFilePtr) Lock() vfsLockState {
-	return vfsLockState(memory{p}.readUint32(p.ptr + 2*ptrlen))
-}
-
-func (p vfsFilePtr) SetID(id uint32) vfsFilePtr {
-	memory{p}.writeUint32(p.ptr+ptrlen, id)
-	return p
-}
-
-func (p vfsFilePtr) SetLock(lock vfsLockState) vfsFilePtr {
-	memory{p}.writeUint32(p.ptr+2*ptrlen, uint32(lock))
-	return p
-}

vfs_lock.go

@@ -61,9 +61,8 @@ func vfsLock(ctx context.Context, mod api.Module, pFile uint32, eLock vfsLockSta
 		panic(assertErr())
 	}
 
-	ptr := vfsFilePtr{mod, pFile}
-	file := ptr.OSFile()
-	cLock := ptr.Lock()
+	file := vfsFile.GetOS(ctx, mod, pFile)
+	cLock := vfsFile.GetLock(ctx, mod, pFile)
 
 	switch {
 	case cLock < _NO_LOCK || cLock > _EXCLUSIVE_LOCK:
@@ -95,7 +94,7 @@ func vfsLock(ctx context.Context, mod api.Module, pFile uint32, eLock vfsLockSta
 		if rc := vfsOS.GetSharedLock(file); rc != _OK {
 			return uint32(rc)
 		}
-		ptr.SetLock(_SHARED_LOCK)
+		vfsFile.SetLock(ctx, mod, pFile, _SHARED_LOCK)
 		return _OK
 
 	case _RESERVED_LOCK:
@@ -106,7 +105,7 @@ func vfsLock(ctx context.Context, mod api.Module, pFile uint32, eLock vfsLockSta
 		if rc := vfsOS.GetReservedLock(file); rc != _OK {
 			return uint32(rc)
 		}
-		ptr.SetLock(_RESERVED_LOCK)
+		vfsFile.SetLock(ctx, mod, pFile, _RESERVED_LOCK)
 		return _OK
 
 	case _EXCLUSIVE_LOCK:
@@ -119,12 +118,12 @@ func vfsLock(ctx context.Context, mod api.Module, pFile uint32, eLock vfsLockSta
 			if rc := vfsOS.GetPendingLock(file); rc != _OK {
 				return uint32(rc)
 			}
-			ptr.SetLock(_PENDING_LOCK)
+			vfsFile.SetLock(ctx, mod, pFile, _PENDING_LOCK)
 		}
 		if rc := vfsOS.GetExclusiveLock(file); rc != _OK {
 			return uint32(rc)
 		}
-		ptr.SetLock(_EXCLUSIVE_LOCK)
+		vfsFile.SetLock(ctx, mod, pFile, _EXCLUSIVE_LOCK)
 		return _OK
 
 	default:
@@ -138,9 +137,8 @@ func vfsUnlock(ctx context.Context, mod api.Module, pFile uint32, eLock vfsLockS
 		panic(assertErr())
 	}
 
-	ptr := vfsFilePtr{mod, pFile}
-	file := ptr.OSFile()
-	cLock := ptr.Lock()
+	file := vfsFile.GetOS(ctx, mod, pFile)
+	cLock := vfsFile.GetLock(ctx, mod, pFile)
 
 	// Connection state check.
 	if cLock < _NO_LOCK || cLock > _EXCLUSIVE_LOCK {
@@ -157,12 +155,12 @@ func vfsUnlock(ctx context.Context, mod api.Module, pFile uint32, eLock vfsLockS
 		if rc := vfsOS.DowngradeLock(file, cLock); rc != _OK {
 			return uint32(rc)
 		}
-		ptr.SetLock(_SHARED_LOCK)
+		vfsFile.SetLock(ctx, mod, pFile, _SHARED_LOCK)
 		return _OK
 
 	case _NO_LOCK:
 		rc := vfsOS.ReleaseLock(file, cLock)
-		ptr.SetLock(_NO_LOCK)
+		vfsFile.SetLock(ctx, mod, pFile, _NO_LOCK)
 		return uint32(rc)
 
 	default:
@@ -171,14 +169,13 @@ func vfsUnlock(ctx context.Context, mod api.Module, pFile uint32, eLock vfsLockS
 }
 
 func vfsCheckReservedLock(ctx context.Context, mod api.Module, pFile, pResOut uint32) uint32 {
-	ptr := vfsFilePtr{mod, pFile}
-	cLock := ptr.Lock()
+	cLock := vfsFile.GetLock(ctx, mod, pFile)
 
 	if cLock > _SHARED_LOCK {
 		panic(assertErr())
 	}
 
-	file := ptr.OSFile()
+	file := vfsFile.GetOS(ctx, mod, pFile)
 
 	locked, rc := vfsOS.CheckReservedLock(file)
 	var res uint32

vfs_lock_test.go

@@ -38,10 +38,13 @@ func Test_vfsLock(t *testing.T) {
 		pOutput = 32
 	)
 	mem := newMemory(128)
-	vfsFilePtr{mem.mod, pFile1}.SetID(vfsGetFileID(file1)).SetLock(_NO_LOCK)
-	vfsFilePtr{mem.mod, pFile2}.SetID(vfsGetFileID(file2)).SetLock(_NO_LOCK)
+	ctx, vfs := vfsContext(context.TODO())
+	defer vfs.Close()
 
-	rc := vfsCheckReservedLock(context.TODO(), mem.mod, pFile1, pOutput)
+	vfsFile.Open(ctx, mem.mod, pFile1, file1)
+	vfsFile.Open(ctx, mem.mod, pFile2, file2)
+
+	rc := vfsCheckReservedLock(ctx, mem.mod, pFile1, pOutput)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -49,12 +52,12 @@ func Test_vfsLock(t *testing.T) {
 		t.Error("file was locked")
 	}
 
-	rc = vfsLock(context.TODO(), mem.mod, pFile2, _SHARED_LOCK)
+	rc = vfsLock(ctx, mem.mod, pFile2, _SHARED_LOCK)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
 
-	rc = vfsCheckReservedLock(context.TODO(), mem.mod, pFile1, pOutput)
+	rc = vfsCheckReservedLock(ctx, mem.mod, pFile1, pOutput)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -62,16 +65,16 @@ func Test_vfsLock(t *testing.T) {
 		t.Error("file was locked")
 	}
 
-	rc = vfsLock(context.TODO(), mem.mod, pFile2, _RESERVED_LOCK)
+	rc = vfsLock(ctx, mem.mod, pFile2, _RESERVED_LOCK)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
-	rc = vfsLock(context.TODO(), mem.mod, pFile2, _SHARED_LOCK)
+	rc = vfsLock(ctx, mem.mod, pFile2, _SHARED_LOCK)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
 
-	rc = vfsCheckReservedLock(context.TODO(), mem.mod, pFile1, pOutput)
+	rc = vfsCheckReservedLock(ctx, mem.mod, pFile1, pOutput)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -79,12 +82,12 @@ func Test_vfsLock(t *testing.T) {
 		t.Error("file wasn't locked")
 	}
 
-	rc = vfsLock(context.TODO(), mem.mod, pFile2, _EXCLUSIVE_LOCK)
+	rc = vfsLock(ctx, mem.mod, pFile2, _EXCLUSIVE_LOCK)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
 
-	rc = vfsCheckReservedLock(context.TODO(), mem.mod, pFile1, pOutput)
+	rc = vfsCheckReservedLock(ctx, mem.mod, pFile1, pOutput)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -92,12 +95,12 @@ func Test_vfsLock(t *testing.T) {
 		t.Error("file wasn't locked")
 	}
 
-	rc = vfsLock(context.TODO(), mem.mod, pFile1, _SHARED_LOCK)
+	rc = vfsLock(ctx, mem.mod, pFile1, _SHARED_LOCK)
 	if rc == _OK {
 		t.Fatal("returned", rc)
 	}
 
-	rc = vfsCheckReservedLock(context.TODO(), mem.mod, pFile1, pOutput)
+	rc = vfsCheckReservedLock(ctx, mem.mod, pFile1, pOutput)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -105,12 +108,12 @@ func Test_vfsLock(t *testing.T) {
 		t.Error("file wasn't locked")
 	}
 
-	rc = vfsUnlock(context.TODO(), mem.mod, pFile2, _SHARED_LOCK)
+	rc = vfsUnlock(ctx, mem.mod, pFile2, _SHARED_LOCK)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
 
-	rc = vfsCheckReservedLock(context.TODO(), mem.mod, pFile1, pOutput)
+	rc = vfsCheckReservedLock(ctx, mem.mod, pFile1, pOutput)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -118,7 +121,7 @@ func Test_vfsLock(t *testing.T) {
 		t.Error("file was locked")
 	}
 
-	rc = vfsLock(context.TODO(), mem.mod, pFile1, _SHARED_LOCK)
+	rc = vfsLock(ctx, mem.mod, pFile1, _SHARED_LOCK)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}

vfs_test.go

@@ -16,15 +16,17 @@ import (
 
 func Test_vfsExit(t *testing.T) {
 	mem := newMemory(128)
+	ctx := context.TODO()
 	defer func() { _ = recover() }()
-	vfsExit(context.TODO(), mem.mod, 1)
+	vfsExit(ctx, mem.mod, 1)
 	t.Error("want panic")
 }
 
 func Test_vfsLocaltime(t *testing.T) {
 	mem := newMemory(128)
+	ctx := context.TODO()
 
-	rc := vfsLocaltime(context.TODO(), mem.mod, 0, 4)
+	rc := vfsLocaltime(ctx, mem.mod, 0, 4)
 	if rc != 0 {
 		t.Fatal("returned", rc)
 	}
@@ -71,24 +73,26 @@ func Test_vfsRandomness(t *testing.T) {
 }
 
 func Test_vfsSleep(t *testing.T) {
-	start := time.Now()
+	ctx := context.TODO()
 
-	rc := vfsSleep(context.TODO(), 0, 123456)
+	now := time.Now()
+	rc := vfsSleep(ctx, 0, 123456)
 	if rc != 0 {
 		t.Fatal("returned", rc)
 	}
 
 	want := 123456 * time.Microsecond
-	if got := time.Since(start); got < want {
+	if got := time.Since(now); got < want {
 		t.Errorf("got %v, want %v", got, want)
 	}
 }
 
 func Test_vfsCurrentTime(t *testing.T) {
 	mem := newMemory(128)
+	ctx := context.TODO()
 
 	now := time.Now()
-	rc := vfsCurrentTime(context.TODO(), mem.mod, 0, 4)
+	rc := vfsCurrentTime(ctx, mem.mod, 0, 4)
 	if rc != 0 {
 		t.Fatal("returned", rc)
 	}
@@ -101,10 +105,11 @@ func Test_vfsCurrentTime(t *testing.T) {
 
 func Test_vfsCurrentTime64(t *testing.T) {
 	mem := newMemory(128)
+	ctx := context.TODO()
 
 	now := time.Now()
 	time.Sleep(time.Millisecond)
-	rc := vfsCurrentTime64(context.TODO(), mem.mod, 0, 4)
+	rc := vfsCurrentTime64(ctx, mem.mod, 0, 4)
 	if rc != 0 {
 		t.Fatal("returned", rc)
 	}
@@ -119,13 +124,14 @@ func Test_vfsCurrentTime64(t *testing.T) {
 func Test_vfsFullPathname(t *testing.T) {
 	mem := newMemory(128 + _MAX_PATHNAME)
 	mem.writeString(4, ".")
+	ctx := context.TODO()
 
-	rc := vfsFullPathname(context.TODO(), mem.mod, 0, 4, 0, 8)
+	rc := vfsFullPathname(ctx, mem.mod, 0, 4, 0, 8)
 	if rc != uint32(CANTOPEN_FULLPATH) {
 		t.Errorf("returned %d, want %d", rc, CANTOPEN_FULLPATH)
 	}
 
-	rc = vfsFullPathname(context.TODO(), mem.mod, 0, 4, _MAX_PATHNAME, 8)
+	rc = vfsFullPathname(ctx, mem.mod, 0, 4, _MAX_PATHNAME, 8)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -147,8 +153,9 @@ func Test_vfsDelete(t *testing.T) {
 
 	mem := newMemory(128 + _MAX_PATHNAME)
 	mem.writeString(4, name)
+	ctx := context.TODO()
 
-	rc := vfsDelete(context.TODO(), mem.mod, 0, 4, 1)
+	rc := vfsDelete(ctx, mem.mod, 0, 4, 1)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -157,7 +164,7 @@ func Test_vfsDelete(t *testing.T) {
 		t.Fatal("did not delete the file")
 	}
 
-	rc = vfsDelete(context.TODO(), mem.mod, 0, 4, 1)
+	rc = vfsDelete(ctx, mem.mod, 0, 4, 1)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -177,8 +184,9 @@ func Test_vfsAccess(t *testing.T) {
 
 	mem := newMemory(128 + _MAX_PATHNAME)
 	mem.writeString(8, dir)
+	ctx := context.TODO()
 
-	rc := vfsAccess(context.TODO(), mem.mod, 0, 8, _ACCESS_EXISTS, 4)
+	rc := vfsAccess(ctx, mem.mod, 0, 8, _ACCESS_EXISTS, 4)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -186,7 +194,7 @@ func Test_vfsAccess(t *testing.T) {
 		t.Error("directory did not exist")
 	}
 
-	rc = vfsAccess(context.TODO(), mem.mod, 0, 8, _ACCESS_READWRITE, 4)
+	rc = vfsAccess(ctx, mem.mod, 0, 8, _ACCESS_READWRITE, 4)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -195,7 +203,7 @@ func Test_vfsAccess(t *testing.T) {
 	}
 
 	mem.writeString(8, file)
-	rc = vfsAccess(context.TODO(), mem.mod, 0, 8, _ACCESS_READWRITE, 4)
+	rc = vfsAccess(ctx, mem.mod, 0, 8, _ACCESS_READWRITE, 4)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -206,9 +214,11 @@ func Test_vfsAccess(t *testing.T) {
 
 func Test_vfsFile(t *testing.T) {
 	mem := newMemory(128)
+	ctx, vfs := vfsContext(context.TODO())
+	defer vfs.Close()
 
 	// Open a temporary file.
-	rc := vfsOpen(context.TODO(), mem.mod, 0, 0, 4, OPEN_CREATE|OPEN_EXCLUSIVE|OPEN_READWRITE|OPEN_DELETEONCLOSE, 0)
+	rc := vfsOpen(ctx, mem.mod, 0, 0, 4, OPEN_CREATE|OPEN_EXCLUSIVE|OPEN_READWRITE|OPEN_DELETEONCLOSE, 0)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -216,13 +226,13 @@ func Test_vfsFile(t *testing.T) {
 	// Write stuff.
 	text := "Hello world!"
 	mem.writeString(16, text)
-	rc = vfsWrite(context.TODO(), mem.mod, 4, 16, uint32(len(text)), 0)
+	rc = vfsWrite(ctx, mem.mod, 4, 16, uint32(len(text)), 0)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
 
 	// Check file size.
-	rc = vfsFileSize(context.TODO(), mem.mod, 4, 16)
+	rc = vfsFileSize(ctx, mem.mod, 4, 16)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -231,7 +241,7 @@ func Test_vfsFile(t *testing.T) {
 	}
 
 	// Partial read at offset.
-	rc = vfsRead(context.TODO(), mem.mod, 4, 16, uint32(len(text)), 4)
+	rc = vfsRead(ctx, mem.mod, 4, 16, uint32(len(text)), 4)
 	if rc != uint32(IOERR_SHORT_READ) {
 		t.Fatal("returned", rc)
 	}
@@ -240,13 +250,13 @@ func Test_vfsFile(t *testing.T) {
 	}
 
 	// Truncate the file.
-	rc = vfsTruncate(context.TODO(), mem.mod, 4, 4)
+	rc = vfsTruncate(ctx, mem.mod, 4, 4)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
 
 	// Check file size.
-	rc = vfsFileSize(context.TODO(), mem.mod, 4, 16)
+	rc = vfsFileSize(ctx, mem.mod, 4, 16)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -255,7 +265,7 @@ func Test_vfsFile(t *testing.T) {
 	}
 
 	// Read at offset.
-	rc = vfsRead(context.TODO(), mem.mod, 4, 32, 4, 0)
+	rc = vfsRead(ctx, mem.mod, 4, 32, 4, 0)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -264,7 +274,7 @@ func Test_vfsFile(t *testing.T) {
 	}
 
 	// Close the file.
-	rc = vfsClose(context.TODO(), mem.mod, 4)
+	rc = vfsClose(ctx, mem.mod, 4)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}