Documentation, tests.

Bumps [golang.org/x/sync](https://github.com/golang/sync) from 0.1.0 to 0.2.0.
- [Commits](https://github.com/golang/sync/compare/v0.1.0...v0.2.0)

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

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

.github/workflows/go.yml

@@ -5,6 +5,7 @@ on:
     branches: [ "main" ]
   pull_request:
     branches: [ "main" ]
+  workflow_dispatch:
 
 jobs:
   test:

README.md

@@ -15,11 +15,13 @@ provides a [`database/sql`](https://pkg.go.dev/database/sql) driver
 ([example usage](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#example-package)).
 - Package [`github.com/ncruces/go-sqlite3/embed`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/embed)
 embeds a build of SQLite into your application.
+- Package [`github.com/ncruces/go-sqlite3/sqlite3vfs`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/sqlite3vfs)
+wraps the [C SQLite VFS API](https://www.sqlite.org/vfs.html) and provides a pure Go implementation.
 
 ### Caveats
 
 This module replaces the SQLite [OS Interface](https://www.sqlite.org/vfs.html) (aka VFS)
-with a [pure Go](internal/vfs/) implementation.
+with a [pure Go](sqlite3vfs/) implementation.
 This has numerous benefits, but also comes with some drawbacks.
 
 #### Write-Ahead Logging
@@ -73,7 +75,7 @@ Performance is tested by running
   - [ ] in-memory VFS
   - [ ] read-only VFS, wrapping an [`io.ReaderAt`](https://pkg.go.dev/io#ReaderAt)
   - [ ] cloud-based VFS, based on [Cloud Backed SQLite](https://sqlite.org/cloudsqlite/doc/trunk/www/index.wiki)
-  - [ ] custom VFS API
+  - [x] custom VFS API
 
 ### Alternatives
 

backup.go

@@ -1,6 +1,6 @@
 package sqlite3
 
-// Backup is a handle to an open BLOB.
+// Backup is an handle to an ongoing online backup operation.
 //
 // https://www.sqlite.org/c3ref/backup.html
 type Backup struct {
@@ -11,7 +11,7 @@ type Backup struct {
 
 // Backup backs up srcDB on the src connection to the "main" database in dstURI.
 //
-// Backup calls [Open] to open the SQLite database file dstURI,
+// Backup opens the SQLite database file dstURI,
 // and blocks until the entire backup is complete.
 // Use [Conn.BackupInit] for incremental backup.
 //
@@ -28,7 +28,7 @@ func (src *Conn) Backup(srcDB, dstURI string) error {
 
 // Restore restores dstDB on the dst connection from the "main" database in srcURI.
 //
-// Restore calls [Open] to open the SQLite database file srcURI,
+// Restore opens the SQLite database file srcURI,
 // and blocks until the entire restore is complete.
 //
 // https://www.sqlite.org/backup.html
@@ -48,7 +48,7 @@ func (dst *Conn) Restore(dstDB, srcURI string) error {
 
 // BackupInit initializes a backup operation to copy the content of one database into another.
 //
-// BackupInit calls [Open] to open the SQLite database file dstURI,
+// BackupInit opens 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.
 //

blob.go

@@ -11,7 +11,7 @@ import (
 // [database/sql.DB.Exec] and similar methods.
 type ZeroBlob int64
 
-// Blob is a handle to an open BLOB.
+// Blob is an handle to an open BLOB.
 //
 // It implements [io.ReadWriteSeeker] for incremental BLOB I/O.
 //

conn.go

@@ -278,7 +278,8 @@ func (c *Conn) SetInterrupt(ctx context.Context) (old context.Context) {
 			break
 
 		case <-ctx.Done(): // Done was closed.
-			buf := util.View(c.mod, c.handle+c.api.interrupt, 4)
+			const isInterruptedOffset = 280
+			buf := util.View(c.mod, c.handle+isInterruptedOffset, 4)
 			(*atomic.Uint32)(unsafe.Pointer(&buf[0])).Store(1)
 			// Wait for the next call to SetInterrupt.
 			<-waiter
@@ -294,7 +295,8 @@ func (c *Conn) checkInterrupt() bool {
 	if c.interrupt == nil || c.interrupt.Err() == nil {
 		return false
 	}
-	buf := util.View(c.mod, c.handle+c.api.interrupt, 4)
+	const isInterruptedOffset = 280
+	buf := util.View(c.mod, c.handle+isInterruptedOffset, 4)
 	(*atomic.Uint32)(unsafe.Pointer(&buf[0])).Store(1)
 	return true
 }
@@ -334,4 +336,6 @@ type DriverConn interface {
 
 	Savepoint() Savepoint
 	OpenBlob(db, table, column string, row int64, write bool) (*Blob, error)
+
+	SetInterrupt(ctx context.Context) (old context.Context)
 }

const.go

@@ -137,34 +137,23 @@ const (
 	AUTH_USER               ExtendedErrorCode = xErrorCode(AUTH) | (1 << 8)
 )
 
-// OpenFlag is a flag for a file open operation.
+// OpenFlag is a flag for the [OpenFlags] function.
 //
 // https://www.sqlite.org/c3ref/c_open_autoproxy.html
 type OpenFlag uint32
 
 const (
-	OPEN_READONLY      OpenFlag = 0x00000001 /* Ok for sqlite3_open_v2() */
-	OPEN_READWRITE     OpenFlag = 0x00000002 /* Ok for sqlite3_open_v2() */
-	OPEN_CREATE        OpenFlag = 0x00000004 /* Ok for sqlite3_open_v2() */
-	OPEN_DELETEONCLOSE OpenFlag = 0x00000008 /* VFS only */
-	OPEN_EXCLUSIVE     OpenFlag = 0x00000010 /* VFS only */
-	OPEN_AUTOPROXY     OpenFlag = 0x00000020 /* VFS only */
-	OPEN_URI           OpenFlag = 0x00000040 /* Ok for sqlite3_open_v2() */
-	OPEN_MEMORY        OpenFlag = 0x00000080 /* Ok for sqlite3_open_v2() */
-	OPEN_MAIN_DB       OpenFlag = 0x00000100 /* VFS only */
-	OPEN_TEMP_DB       OpenFlag = 0x00000200 /* VFS only */
-	OPEN_TRANSIENT_DB  OpenFlag = 0x00000400 /* VFS only */
-	OPEN_MAIN_JOURNAL  OpenFlag = 0x00000800 /* VFS only */
-	OPEN_TEMP_JOURNAL  OpenFlag = 0x00001000 /* VFS only */
-	OPEN_SUBJOURNAL    OpenFlag = 0x00002000 /* VFS only */
-	OPEN_SUPER_JOURNAL OpenFlag = 0x00004000 /* VFS only */
-	OPEN_NOMUTEX       OpenFlag = 0x00008000 /* Ok for sqlite3_open_v2() */
-	OPEN_FULLMUTEX     OpenFlag = 0x00010000 /* Ok for sqlite3_open_v2() */
-	OPEN_SHAREDCACHE   OpenFlag = 0x00020000 /* Ok for sqlite3_open_v2() */
-	OPEN_PRIVATECACHE  OpenFlag = 0x00040000 /* Ok for sqlite3_open_v2() */
-	OPEN_WAL           OpenFlag = 0x00080000 /* VFS only */
-	OPEN_NOFOLLOW      OpenFlag = 0x01000000 /* Ok for sqlite3_open_v2() */
-	OPEN_EXRESCODE     OpenFlag = 0x02000000 /* Extended result codes */
+	OPEN_READONLY     OpenFlag = 0x00000001 /* Ok for sqlite3_open_v2() */
+	OPEN_READWRITE    OpenFlag = 0x00000002 /* Ok for sqlite3_open_v2() */
+	OPEN_CREATE       OpenFlag = 0x00000004 /* Ok for sqlite3_open_v2() */
+	OPEN_URI          OpenFlag = 0x00000040 /* Ok for sqlite3_open_v2() */
+	OPEN_MEMORY       OpenFlag = 0x00000080 /* Ok for sqlite3_open_v2() */
+	OPEN_NOMUTEX      OpenFlag = 0x00008000 /* Ok for sqlite3_open_v2() */
+	OPEN_FULLMUTEX    OpenFlag = 0x00010000 /* Ok for sqlite3_open_v2() */
+	OPEN_SHAREDCACHE  OpenFlag = 0x00020000 /* Ok for sqlite3_open_v2() */
+	OPEN_PRIVATECACHE OpenFlag = 0x00040000 /* Ok for sqlite3_open_v2() */
+	OPEN_NOFOLLOW     OpenFlag = 0x01000000 /* Ok for sqlite3_open_v2() */
+	OPEN_EXRESCODE    OpenFlag = 0x02000000 /* Extended result codes */
 )
 
 // PrepareFlag is a flag that can be passed to [Conn.PrepareFlags].

driver/driver.go

@@ -16,7 +16,7 @@
 //
 //	sql.Open("sqlite3", "file:demo.db?_pragma=busy_timeout(10000)&_pragma=locking_mode(normal)")
 //
-// If no PRAGMAs are specifed, a busy timeout of 1 minute
+// If no PRAGMAs are specified, a busy timeout of 1 minute
 // and normal locking mode are used.
 //
 // [URI]: https://www.sqlite.org/uri.html
@@ -213,10 +213,7 @@ func (c conn) ExecContext(ctx context.Context, query string, args []driver.Named
 		return nil, err
 	}
 
-	return result{
-		c.conn.LastInsertRowID(),
-		c.conn.Changes(),
-	}, nil
+	return newResult(c.conn), nil
 }
 
 func (c conn) Savepoint() sqlite3.Savepoint {
@@ -227,6 +224,10 @@ func (c conn) OpenBlob(db, table, column string, row int64, write bool) (*sqlite
 	return c.conn.OpenBlob(db, table, column, row, write)
 }
 
+func (c conn) SetInterrupt(ctx context.Context) (old context.Context) {
+	return c.conn.SetInterrupt(ctx)
+}
+
 type stmt struct {
 	stmt *sqlite3.Stmt
 	conn *sqlite3.Conn
@@ -276,10 +277,7 @@ func (s stmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver
 		return nil, err
 	}
 
-	return result{
-		int64(s.conn.LastInsertRowID()),
-		int64(s.conn.Changes()),
-	}, nil
+	return newResult(s.conn), nil
 }
 
 func (s stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
@@ -343,6 +341,17 @@ func (s stmt) CheckNamedValue(arg *driver.NamedValue) error {
 	}
 }
 
+func newResult(c *sqlite3.Conn) driver.Result {
+	rows := c.Changes()
+	if rows != 0 {
+		id := c.LastInsertRowID()
+		if id != 0 {
+			return result{id, rows}
+		}
+	}
+	return resultRowsAffected(rows)
+}
+
 type result struct{ lastInsertId, rowsAffected int64 }
 
 func (r result) LastInsertId() (int64, error) {
@@ -353,6 +362,16 @@ func (r result) RowsAffected() (int64, error) {
 	return r.rowsAffected, nil
 }
 
+type resultRowsAffected int64
+
+func (r resultRowsAffected) LastInsertId() (int64, error) {
+	return 0, nil
+}
+
+func (r resultRowsAffected) RowsAffected() (int64, error) {
+	return int64(r), nil
+}
+
 type rows struct {
 	ctx  context.Context
 	stmt *sqlite3.Stmt

embed/README.md

@@ -1,6 +1,6 @@
 # Embeddable WASM build of SQLite
 
-This folder includes an embeddable WASM build of SQLite 3.41.2 for use with
+This folder includes an embeddable WASM build of SQLite 3.42.0 for use with
 [`github.com/ncruces/go-sqlite3`](https://pkg.go.dev/github.com/ncruces/go-sqlite3).
 
 The following optional features are compiled in:

embed/build.sh

@@ -17,7 +17,6 @@ WASI_SDK="$ROOT/tools/wasi-sdk-20.0/bin"
 	-Wl,--initial-memory=327680 \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
-	-D_HAVE_SQLITE_CONFIG_H \
 	$(awk '{print "-Wl,--export="$0}' exports.txt)
 
 trap 'rm -f sqlite3.tmp' EXIT

embed/exports.txt

@@ -44,5 +44,4 @@ sqlite3_backup_init
 sqlite3_backup_step
 sqlite3_backup_finish
 sqlite3_backup_remaining
-sqlite3_backup_pagecount
-sqlite3_interrupt_offset
+sqlite3_backup_pagecount

error.go

@@ -3,6 +3,8 @@ package sqlite3
 import (
 	"strconv"
 	"strings"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
 )
 
 // Error wraps an SQLite Error Code.
@@ -83,72 +85,7 @@ func (e *Error) SQL() string {
 
 // Error implements the error interface.
 func (e ErrorCode) Error() string {
-	switch e {
-	case _OK:
-		return "sqlite3: not an error"
-	case _ROW:
-		return "sqlite3: another row available"
-	case _DONE:
-		return "sqlite3: no more rows available"
-
-	case ERROR:
-		return "sqlite3: SQL logic error"
-	case INTERNAL:
-		break
-	case PERM:
-		return "sqlite3: access permission denied"
-	case ABORT:
-		return "sqlite3: query aborted"
-	case BUSY:
-		return "sqlite3: database is locked"
-	case LOCKED:
-		return "sqlite3: database table is locked"
-	case NOMEM:
-		return "sqlite3: out of memory"
-	case READONLY:
-		return "sqlite3: attempt to write a readonly database"
-	case INTERRUPT:
-		return "sqlite3: interrupted"
-	case IOERR:
-		return "sqlite3: disk I/O error"
-	case CORRUPT:
-		return "sqlite3: database disk image is malformed"
-	case NOTFOUND:
-		return "sqlite3: unknown operation"
-	case FULL:
-		return "sqlite3: database or disk is full"
-	case CANTOPEN:
-		return "sqlite3: unable to open database file"
-	case PROTOCOL:
-		return "sqlite3: locking protocol"
-	case FORMAT:
-		break
-	case SCHEMA:
-		return "sqlite3: database schema has changed"
-	case TOOBIG:
-		return "sqlite3: string or blob too big"
-	case CONSTRAINT:
-		return "sqlite3: constraint failed"
-	case MISMATCH:
-		return "sqlite3: datatype mismatch"
-	case MISUSE:
-		return "sqlite3: bad parameter or other API misuse"
-	case NOLFS:
-		break
-	case AUTH:
-		return "sqlite3: authorization denied"
-	case EMPTY:
-		break
-	case RANGE:
-		return "sqlite3: column index out of range"
-	case NOTADB:
-		return "sqlite3: file is not a database"
-	case NOTICE:
-		return "sqlite3: notification message"
-	case WARNING:
-		return "sqlite3: warning message"
-	}
-	return "sqlite3: unknown error"
+	return util.ErrorCodeString(uint32(e))
 }
 
 // Temporary returns true for [BUSY] errors.
@@ -158,17 +95,7 @@ func (e ErrorCode) Temporary() bool {
 
 // Error implements the error interface.
 func (e ExtendedErrorCode) Error() string {
-	switch x := ErrorCode(e); {
-	case e == ABORT_ROLLBACK:
-		return "sqlite3: abort due to ROLLBACK"
-	case x < _ROW:
-		return x.Error()
-	case e == _ROW:
-		return "sqlite3: another row available"
-	case e == _DONE:
-		return "sqlite3: no more rows available"
-	}
-	return "sqlite3: unknown error"
+	return util.ErrorCodeString(uint32(e))
 }
 
 // Is tests whether this error matches a given [ErrorCode].

go.mod

@@ -5,8 +5,8 @@ go 1.19
 require (
 	github.com/ncruces/julianday v0.1.5
 	github.com/tetratelabs/wazero v1.1.0
-	golang.org/x/sync v0.1.0
-	golang.org/x/sys v0.7.0
+	golang.org/x/sync v0.2.0
+	golang.org/x/sys v0.8.0
 )
 
 retract v0.4.0 // tagged from the wrong branch

go.sum

@@ -2,7 +2,7 @@ github.com/ncruces/julianday v0.1.5 h1:hDJ9ejiMp3DHsoZ5KW4c1lwfMjbARS7u/gbYcd0FB
 github.com/ncruces/julianday v0.1.5/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
 github.com/tetratelabs/wazero v1.1.0 h1:EByoAhC+QcYpwSZJSs/aV0uokxPwBgKxfiokSUwAknQ=
 github.com/tetratelabs/wazero v1.1.0/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.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
-golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sync v0.2.0 h1:PUR+T4wwASmuSTYdKjYHI5TD22Wy5ogLU5qZCOLxBrI=
+golang.org/x/sync v0.2.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

internal/util/const.go

@@ -0,0 +1,116 @@
+package util
+
+// https://sqlite.com/matrix/rescode.html
+const (
+	OK = 0 /* Successful result */
+
+	ERROR      = 1  /* Generic error */
+	INTERNAL   = 2  /* Internal logic error in SQLite */
+	PERM       = 3  /* Access permission denied */
+	ABORT      = 4  /* Callback routine requested an abort */
+	BUSY       = 5  /* The database file is locked */
+	LOCKED     = 6  /* A table in the database is locked */
+	NOMEM      = 7  /* A malloc() failed */
+	READONLY   = 8  /* Attempt to write a readonly database */
+	INTERRUPT  = 9  /* Operation terminated by sqlite3_interrupt() */
+	IOERR      = 10 /* Some kind of disk I/O error occurred */
+	CORRUPT    = 11 /* The database disk image is malformed */
+	NOTFOUND   = 12 /* Unknown opcode in sqlite3_file_control() */
+	FULL       = 13 /* Insertion failed because database is full */
+	CANTOPEN   = 14 /* Unable to open the database file */
+	PROTOCOL   = 15 /* Database lock protocol error */
+	EMPTY      = 16 /* Internal use only */
+	SCHEMA     = 17 /* The database schema changed */
+	TOOBIG     = 18 /* String or BLOB exceeds size limit */
+	CONSTRAINT = 19 /* Abort due to constraint violation */
+	MISMATCH   = 20 /* Data type mismatch */
+	MISUSE     = 21 /* Library used incorrectly */
+	NOLFS      = 22 /* Uses OS features not supported on host */
+	AUTH       = 23 /* Authorization denied */
+	FORMAT     = 24 /* Not used */
+	RANGE      = 25 /* 2nd parameter to sqlite3_bind out of range */
+	NOTADB     = 26 /* File opened that is not a database file */
+	NOTICE     = 27 /* Notifications from sqlite3_log() */
+	WARNING    = 28 /* Warnings from sqlite3_log() */
+
+	ROW  = 100 /* sqlite3_step() has another row ready */
+	DONE = 101 /* sqlite3_step() has finished executing */
+
+	ERROR_MISSING_COLLSEQ   = ERROR | (1 << 8)
+	ERROR_RETRY             = ERROR | (2 << 8)
+	ERROR_SNAPSHOT          = ERROR | (3 << 8)
+	IOERR_READ              = IOERR | (1 << 8)
+	IOERR_SHORT_READ        = IOERR | (2 << 8)
+	IOERR_WRITE             = IOERR | (3 << 8)
+	IOERR_FSYNC             = IOERR | (4 << 8)
+	IOERR_DIR_FSYNC         = IOERR | (5 << 8)
+	IOERR_TRUNCATE          = IOERR | (6 << 8)
+	IOERR_FSTAT             = IOERR | (7 << 8)
+	IOERR_UNLOCK            = IOERR | (8 << 8)
+	IOERR_RDLOCK            = IOERR | (9 << 8)
+	IOERR_DELETE            = IOERR | (10 << 8)
+	IOERR_BLOCKED           = IOERR | (11 << 8)
+	IOERR_NOMEM             = IOERR | (12 << 8)
+	IOERR_ACCESS            = IOERR | (13 << 8)
+	IOERR_CHECKRESERVEDLOCK = IOERR | (14 << 8)
+	IOERR_LOCK              = IOERR | (15 << 8)
+	IOERR_CLOSE             = IOERR | (16 << 8)
+	IOERR_DIR_CLOSE         = IOERR | (17 << 8)
+	IOERR_SHMOPEN           = IOERR | (18 << 8)
+	IOERR_SHMSIZE           = IOERR | (19 << 8)
+	IOERR_SHMLOCK           = IOERR | (20 << 8)
+	IOERR_SHMMAP            = IOERR | (21 << 8)
+	IOERR_SEEK              = IOERR | (22 << 8)
+	IOERR_DELETE_NOENT      = IOERR | (23 << 8)
+	IOERR_MMAP              = IOERR | (24 << 8)
+	IOERR_GETTEMPPATH       = IOERR | (25 << 8)
+	IOERR_CONVPATH          = IOERR | (26 << 8)
+	IOERR_VNODE             = IOERR | (27 << 8)
+	IOERR_AUTH              = IOERR | (28 << 8)
+	IOERR_BEGIN_ATOMIC      = IOERR | (29 << 8)
+	IOERR_COMMIT_ATOMIC     = IOERR | (30 << 8)
+	IOERR_ROLLBACK_ATOMIC   = IOERR | (31 << 8)
+	IOERR_DATA              = IOERR | (32 << 8)
+	IOERR_CORRUPTFS         = IOERR | (33 << 8)
+	LOCKED_SHAREDCACHE      = LOCKED | (1 << 8)
+	LOCKED_VTAB             = LOCKED | (2 << 8)
+	BUSY_RECOVERY           = BUSY | (1 << 8)
+	BUSY_SNAPSHOT           = BUSY | (2 << 8)
+	BUSY_TIMEOUT            = BUSY | (3 << 8)
+	CANTOPEN_NOTEMPDIR      = CANTOPEN | (1 << 8)
+	CANTOPEN_ISDIR          = CANTOPEN | (2 << 8)
+	CANTOPEN_FULLPATH       = CANTOPEN | (3 << 8)
+	CANTOPEN_CONVPATH       = CANTOPEN | (4 << 8)
+	CANTOPEN_DIRTYWAL       = CANTOPEN | (5 << 8) /* Not Used */
+	CANTOPEN_SYMLINK        = CANTOPEN | (6 << 8)
+	CORRUPT_VTAB            = CORRUPT | (1 << 8)
+	CORRUPT_SEQUENCE        = CORRUPT | (2 << 8)
+	CORRUPT_INDEX           = CORRUPT | (3 << 8)
+	READONLY_RECOVERY       = READONLY | (1 << 8)
+	READONLY_CANTLOCK       = READONLY | (2 << 8)
+	READONLY_ROLLBACK       = READONLY | (3 << 8)
+	READONLY_DBMOVED        = READONLY | (4 << 8)
+	READONLY_CANTINIT       = READONLY | (5 << 8)
+	READONLY_DIRECTORY      = READONLY | (6 << 8)
+	ABORT_ROLLBACK          = ABORT | (2 << 8)
+	CONSTRAINT_CHECK        = CONSTRAINT | (1 << 8)
+	CONSTRAINT_COMMITHOOK   = CONSTRAINT | (2 << 8)
+	CONSTRAINT_FOREIGNKEY   = CONSTRAINT | (3 << 8)
+	CONSTRAINT_FUNCTION     = CONSTRAINT | (4 << 8)
+	CONSTRAINT_NOTNULL      = CONSTRAINT | (5 << 8)
+	CONSTRAINT_PRIMARYKEY   = CONSTRAINT | (6 << 8)
+	CONSTRAINT_TRIGGER      = CONSTRAINT | (7 << 8)
+	CONSTRAINT_UNIQUE       = CONSTRAINT | (8 << 8)
+	CONSTRAINT_VTAB         = CONSTRAINT | (9 << 8)
+	CONSTRAINT_ROWID        = CONSTRAINT | (10 << 8)
+	CONSTRAINT_PINNED       = CONSTRAINT | (11 << 8)
+	CONSTRAINT_DATATYPE     = CONSTRAINT | (12 << 8)
+	NOTICE_RECOVER_WAL      = NOTICE | (1 << 8)
+	NOTICE_RECOVER_ROLLBACK = NOTICE | (2 << 8)
+	NOTICE_RBU              = NOTICE | (3 << 8)
+	WARNING_AUTOINDEX       = WARNING | (1 << 8)
+	AUTH_USER               = AUTH | (1 << 8)
+
+	OK_LOAD_PERMANENTLY = OK | (1 << 8)
+	OK_SYMLINK          = OK | (2 << 8) /* internal use only */
+)

internal/util/error.go

@@ -23,6 +23,7 @@ const (
 	OffsetErr    = ErrorString("sqlite3: invalid offset")
 	TailErr      = ErrorString("sqlite3: multiple statements")
 	IsolationErr = ErrorString("sqlite3: unsupported isolation level")
+	NoVFSErr     = ErrorString("sqlite3: no such vfs: ")
 )
 
 func AssertErr() ErrorString {
@@ -40,3 +41,75 @@ func Finalizer[T any](skip int) func(*T) {
 	}
 	return func(*T) { panic(ErrorString(msg)) }
 }
+
+func ErrorCodeString(rc uint32) string {
+	switch rc {
+	case ABORT_ROLLBACK:
+		return "sqlite3: abort due to ROLLBACK"
+	case ROW:
+		return "sqlite3: another row available"
+	case DONE:
+		return "sqlite3: no more rows available"
+	}
+	switch rc & 0xff {
+	case OK:
+		return "sqlite3: not an error"
+	case ERROR:
+		return "sqlite3: SQL logic error"
+	case INTERNAL:
+		break
+	case PERM:
+		return "sqlite3: access permission denied"
+	case ABORT:
+		return "sqlite3: query aborted"
+	case BUSY:
+		return "sqlite3: database is locked"
+	case LOCKED:
+		return "sqlite3: database table is locked"
+	case NOMEM:
+		return "sqlite3: out of memory"
+	case READONLY:
+		return "sqlite3: attempt to write a readonly database"
+	case INTERRUPT:
+		return "sqlite3: interrupted"
+	case IOERR:
+		return "sqlite3: disk I/O error"
+	case CORRUPT:
+		return "sqlite3: database disk image is malformed"
+	case NOTFOUND:
+		return "sqlite3: unknown operation"
+	case FULL:
+		return "sqlite3: database or disk is full"
+	case CANTOPEN:
+		return "sqlite3: unable to open database file"
+	case PROTOCOL:
+		return "sqlite3: locking protocol"
+	case FORMAT:
+		break
+	case SCHEMA:
+		return "sqlite3: database schema has changed"
+	case TOOBIG:
+		return "sqlite3: string or blob too big"
+	case CONSTRAINT:
+		return "sqlite3: constraint failed"
+	case MISMATCH:
+		return "sqlite3: datatype mismatch"
+	case MISUSE:
+		return "sqlite3: bad parameter or other API misuse"
+	case NOLFS:
+		break
+	case AUTH:
+		return "sqlite3: authorization denied"
+	case EMPTY:
+		break
+	case RANGE:
+		return "sqlite3: column index out of range"
+	case NOTADB:
+		return "sqlite3: file is not a database"
+	case NOTICE:
+		return "sqlite3: notification message"
+	case WARNING:
+		return "sqlite3: warning message"
+	}
+	return "sqlite3: unknown error"
+}

internal/util/func.go

@@ -10,72 +10,93 @@ import (
 type i32 interface{ ~int32 | ~uint32 }
 type i64 interface{ ~int64 | ~uint64 }
 
-func RegisterFuncII[TR, T0 i32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0) TR) {
+type funcII[TR, T0 i32] func(context.Context, api.Module, T0) TR
+
+func (fn funcII[TR, T0]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	stack[0] = uint64(fn(ctx, mod, T0(stack[0])))
+}
+
+func ExportFuncII[TR, T0 i32](mod wazero.HostModuleBuilder, name string, fn func(context.Context, api.Module, T0) TR) {
 	mod.NewFunctionBuilder().
-		WithGoModuleFunction(api.GoModuleFunc(
-			func(ctx context.Context, mod api.Module, stack []uint64) {
-				stack[0] = uint64(fn(ctx, mod, T0(stack[0])))
-			}),
+		WithGoModuleFunction(funcII[TR, T0](fn),
 			[]api.ValueType{api.ValueTypeI32}, []api.ValueType{api.ValueTypeI32}).
 		Export(name)
 }
 
-func RegisterFuncIII[TR, T0, T1 i32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1) TR) {
+type funcIII[TR, T0, T1 i32] func(context.Context, api.Module, T0, T1) TR
+
+func (fn funcIII[TR, T0, T1]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1])))
+}
+
+func ExportFuncIII[TR, T0, T1 i32](mod wazero.HostModuleBuilder, name string, fn func(context.Context, api.Module, T0, T1) TR) {
 	mod.NewFunctionBuilder().
-		WithGoModuleFunction(api.GoModuleFunc(
-			func(ctx context.Context, mod api.Module, stack []uint64) {
-				stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1])))
-			}),
+		WithGoModuleFunction(funcIII[TR, T0, T1](fn),
 			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32}, []api.ValueType{api.ValueTypeI32}).
 		Export(name)
 }
 
-func RegisterFuncIIII[TR, T0, T1, T2 i32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1, _ T2) TR) {
+type funcIIII[TR, T0, T1, T2 i32] func(context.Context, api.Module, T0, T1, T2) TR
+
+func (fn funcIIII[TR, T0, T1, T2]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2])))
+}
+
+func ExportFuncIIII[TR, T0, T1, T2 i32](mod wazero.HostModuleBuilder, name string, fn func(context.Context, api.Module, T0, T1, T2) TR) {
 	mod.NewFunctionBuilder().
-		WithGoModuleFunction(api.GoModuleFunc(
-			func(ctx context.Context, mod api.Module, stack []uint64) {
-				stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2])))
-			}),
+		WithGoModuleFunction(funcIIII[TR, T0, T1, T2](fn),
 			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32}, []api.ValueType{api.ValueTypeI32}).
 		Export(name)
 }
 
-func RegisterFuncIIIII[TR, T0, T1, T2, T3 i32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1, _ T2, _ T3) TR) {
+type funcIIIII[TR, T0, T1, T2, T3 i32] func(context.Context, api.Module, T0, T1, T2, T3) TR
+
+func (fn funcIIIII[TR, T0, T1, T2, T3]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3])))
+}
+
+func ExportFuncIIIII[TR, T0, T1, T2, T3 i32](mod wazero.HostModuleBuilder, name string, fn func(context.Context, api.Module, T0, T1, T2, T3) TR) {
 	mod.NewFunctionBuilder().
-		WithGoModuleFunction(api.GoModuleFunc(
-			func(ctx context.Context, mod api.Module, stack []uint64) {
-				stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3])))
-			}),
+		WithGoModuleFunction(funcIIIII[TR, T0, T1, T2, T3](fn),
 			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32}, []api.ValueType{api.ValueTypeI32}).
 		Export(name)
 }
 
-func RegisterFuncIIIIII[TR, T0, T1, T2, T3, T4 i32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1, _ T2, _ T3, _ T4) TR) {
+type funcIIIIII[TR, T0, T1, T2, T3, T4 i32] func(context.Context, api.Module, T0, T1, T2, T3, T4) TR
+
+func (fn funcIIIIII[TR, T0, T1, T2, T3, T4]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3]), T4(stack[4])))
+}
+
+func ExportFuncIIIIII[TR, T0, T1, T2, T3, T4 i32](mod wazero.HostModuleBuilder, name string, fn func(context.Context, api.Module, T0, T1, T2, T3, T4) TR) {
 	mod.NewFunctionBuilder().
-		WithGoModuleFunction(api.GoModuleFunc(
-			func(ctx context.Context, mod api.Module, stack []uint64) {
-				stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3]), T4(stack[4])))
-			}),
+		WithGoModuleFunction(funcIIIIII[TR, T0, T1, T2, T3, T4](fn),
 			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32}, []api.ValueType{api.ValueTypeI32}).
 		Export(name)
 }
 
-func RegisterFuncIIIIJ[TR, T0, T1, T2 i32, T3 i64](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1, _ T2, _ T3) TR) {
+type funcIIIIJ[TR, T0, T1, T2 i32, T3 i64] func(context.Context, api.Module, T0, T1, T2, T3) TR
+
+func (fn funcIIIIJ[TR, T0, T1, T2, T3]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3])))
+}
+
+func ExportFuncIIIIJ[TR, T0, T1, T2 i32, T3 i64](mod wazero.HostModuleBuilder, name string, fn func(context.Context, api.Module, T0, T1, T2, T3) TR) {
 	mod.NewFunctionBuilder().
-		WithGoModuleFunction(api.GoModuleFunc(
-			func(ctx context.Context, mod api.Module, stack []uint64) {
-				stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3])))
-			}),
+		WithGoModuleFunction(funcIIIIJ[TR, T0, T1, T2, T3](fn),
 			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI64}, []api.ValueType{api.ValueTypeI32}).
 		Export(name)
 }
 
-func RegisterFuncIIJ[TR, T0 i32, T1 i64](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1) TR) {
+type funcIIJ[TR, T0 i32, T1 i64] func(context.Context, api.Module, T0, T1) TR
+
+func (fn funcIIJ[TR, T0, T1]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1])))
+}
+
+func ExportFuncIIJ[TR, T0 i32, T1 i64](mod wazero.HostModuleBuilder, name string, fn func(context.Context, api.Module, T0, T1) TR) {
 	mod.NewFunctionBuilder().
-		WithGoModuleFunction(api.GoModuleFunc(
-			func(ctx context.Context, mod api.Module, stack []uint64) {
-				stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1])))
-			}),
+		WithGoModuleFunction(funcIIJ[TR, T0, T1](fn),
 			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI64}, []api.ValueType{api.ValueTypeI32}).
 		Export(name)
 }

internal/vfs/const.go

@@ -1,217 +0,0 @@
-package vfs
-
-const (
-	_MAX_PATHNAME        = 512
-	_DEFAULT_SECTOR_SIZE = 4096
-)
-
-// https://www.sqlite.org/rescode.html
-type _ErrorCode uint32
-
-const (
-	_OK       _ErrorCode = 0  /* Successful result */
-	_PERM     _ErrorCode = 3  /* Access permission denied */
-	_BUSY     _ErrorCode = 5  /* The database file is locked */
-	_IOERR    _ErrorCode = 10 /* Some kind of disk I/O error occurred */
-	_NOTFOUND _ErrorCode = 12 /* Unknown opcode in sqlite3_file_control() */
-	_CANTOPEN _ErrorCode = 14 /* Unable to open the database file */
-
-	_IOERR_READ              = _IOERR | (1 << 8)
-	_IOERR_SHORT_READ        = _IOERR | (2 << 8)
-	_IOERR_WRITE             = _IOERR | (3 << 8)
-	_IOERR_FSYNC             = _IOERR | (4 << 8)
-	_IOERR_DIR_FSYNC         = _IOERR | (5 << 8)
-	_IOERR_TRUNCATE          = _IOERR | (6 << 8)
-	_IOERR_FSTAT             = _IOERR | (7 << 8)
-	_IOERR_UNLOCK            = _IOERR | (8 << 8)
-	_IOERR_RDLOCK            = _IOERR | (9 << 8)
-	_IOERR_DELETE            = _IOERR | (10 << 8)
-	_IOERR_BLOCKED           = _IOERR | (11 << 8)
-	_IOERR_NOMEM             = _IOERR | (12 << 8)
-	_IOERR_ACCESS            = _IOERR | (13 << 8)
-	_IOERR_CHECKRESERVEDLOCK = _IOERR | (14 << 8)
-	_IOERR_LOCK              = _IOERR | (15 << 8)
-	_IOERR_CLOSE             = _IOERR | (16 << 8)
-	_IOERR_DIR_CLOSE         = _IOERR | (17 << 8)
-	_IOERR_SHMOPEN           = _IOERR | (18 << 8)
-	_IOERR_SHMSIZE           = _IOERR | (19 << 8)
-	_IOERR_SHMLOCK           = _IOERR | (20 << 8)
-	_IOERR_SHMMAP            = _IOERR | (21 << 8)
-	_IOERR_SEEK              = _IOERR | (22 << 8)
-	_IOERR_DELETE_NOENT      = _IOERR | (23 << 8)
-	_IOERR_MMAP              = _IOERR | (24 << 8)
-	_IOERR_GETTEMPPATH       = _IOERR | (25 << 8)
-	_IOERR_CONVPATH          = _IOERR | (26 << 8)
-	_IOERR_VNODE             = _IOERR | (27 << 8)
-	_IOERR_AUTH              = _IOERR | (28 << 8)
-	_IOERR_BEGIN_ATOMIC      = _IOERR | (29 << 8)
-	_IOERR_COMMIT_ATOMIC     = _IOERR | (30 << 8)
-	_IOERR_ROLLBACK_ATOMIC   = _IOERR | (31 << 8)
-	_IOERR_DATA              = _IOERR | (32 << 8)
-	_IOERR_CORRUPTFS         = _IOERR | (33 << 8)
-	_CANTOPEN_NOTEMPDIR      = _CANTOPEN | (1 << 8)
-	_CANTOPEN_ISDIR          = _CANTOPEN | (2 << 8)
-	_CANTOPEN_FULLPATH       = _CANTOPEN | (3 << 8)
-	_CANTOPEN_CONVPATH       = _CANTOPEN | (4 << 8)
-	_CANTOPEN_DIRTYWAL       = _CANTOPEN | (5 << 8) /* Not Used */
-	_CANTOPEN_SYMLINK        = _CANTOPEN | (6 << 8)
-	_OK_SYMLINK              = _OK | (2 << 8) /* internal use only */
-)
-
-// https://www.sqlite.org/c3ref/c_open_autoproxy.html
-type _OpenFlag uint32
-
-const (
-	_OPEN_READONLY      _OpenFlag = 0x00000001 /* Ok for sqlite3_open_v2() */
-	_OPEN_READWRITE     _OpenFlag = 0x00000002 /* Ok for sqlite3_open_v2() */
-	_OPEN_CREATE        _OpenFlag = 0x00000004 /* Ok for sqlite3_open_v2() */
-	_OPEN_DELETEONCLOSE _OpenFlag = 0x00000008 /* VFS only */
-	_OPEN_EXCLUSIVE     _OpenFlag = 0x00000010 /* VFS only */
-	_OPEN_AUTOPROXY     _OpenFlag = 0x00000020 /* VFS only */
-	_OPEN_URI           _OpenFlag = 0x00000040 /* Ok for sqlite3_open_v2() */
-	_OPEN_MEMORY        _OpenFlag = 0x00000080 /* Ok for sqlite3_open_v2() */
-	_OPEN_MAIN_DB       _OpenFlag = 0x00000100 /* VFS only */
-	_OPEN_TEMP_DB       _OpenFlag = 0x00000200 /* VFS only */
-	_OPEN_TRANSIENT_DB  _OpenFlag = 0x00000400 /* VFS only */
-	_OPEN_MAIN_JOURNAL  _OpenFlag = 0x00000800 /* VFS only */
-	_OPEN_TEMP_JOURNAL  _OpenFlag = 0x00001000 /* VFS only */
-	_OPEN_SUBJOURNAL    _OpenFlag = 0x00002000 /* VFS only */
-	_OPEN_SUPER_JOURNAL _OpenFlag = 0x00004000 /* VFS only */
-	_OPEN_NOMUTEX       _OpenFlag = 0x00008000 /* Ok for sqlite3_open_v2() */
-	_OPEN_FULLMUTEX     _OpenFlag = 0x00010000 /* Ok for sqlite3_open_v2() */
-	_OPEN_SHAREDCACHE   _OpenFlag = 0x00020000 /* Ok for sqlite3_open_v2() */
-	_OPEN_PRIVATECACHE  _OpenFlag = 0x00040000 /* Ok for sqlite3_open_v2() */
-	_OPEN_WAL           _OpenFlag = 0x00080000 /* VFS only */
-	_OPEN_NOFOLLOW      _OpenFlag = 0x01000000 /* Ok for sqlite3_open_v2() */
-	_OPEN_EXRESCODE     _OpenFlag = 0x02000000 /* Extended result codes */
-)
-
-// https://www.sqlite.org/c3ref/c_access_exists.html
-type _AccessFlag uint32
-
-const (
-	_ACCESS_EXISTS    _AccessFlag = 0
-	_ACCESS_READWRITE _AccessFlag = 1 /* Used by PRAGMA temp_store_directory */
-	_ACCESS_READ      _AccessFlag = 2 /* Unused */
-)
-
-// https://www.sqlite.org/c3ref/c_sync_dataonly.html
-type _SyncFlag uint32
-
-const (
-	_SYNC_NORMAL   _SyncFlag = 0x00002
-	_SYNC_FULL     _SyncFlag = 0x00003
-	_SYNC_DATAONLY _SyncFlag = 0x00010
-)
-
-// https://www.sqlite.org/c3ref/c_lock_exclusive.html
-type _LockLevel uint32
-
-const (
-	// No locks are held on the database.
-	// The database may be neither read nor written.
-	// Any internally cached data is considered suspect and subject to
-	// verification against the database file before being used.
-	// Other processes can read or write the database as their own locking
-	// states permit.
-	// This is the default state.
-	_LOCK_NONE _LockLevel = 0 /* xUnlock() only */
-
-	// The database may be read but not written.
-	// Any number of processes can hold SHARED locks at the same time,
-	// hence there can be many simultaneous readers.
-	// But no other thread or process is allowed to write to the database file
-	// while one or more SHARED locks are active.
-	_LOCK_SHARED _LockLevel = 1 /* xLock() or xUnlock() */
-
-	// A RESERVED lock means that the process is planning on writing to the
-	// database file at some point in the future but that it is currently just
-	// reading from the file.
-	// Only a single RESERVED lock may be active at one time,
-	// though multiple SHARED locks can coexist with a single RESERVED lock.
-	// RESERVED differs from PENDING in that new SHARED locks can be acquired
-	// while there is a RESERVED lock.
-	_LOCK_RESERVED _LockLevel = 2 /* xLock() only */
-
-	// A PENDING lock means that the process holding the lock wants to write to
-	// the database as soon as possible and is just waiting on all current
-	// SHARED locks to clear so that it can get an EXCLUSIVE lock.
-	// No new SHARED locks are permitted against the database if a PENDING lock
-	// is active, though existing SHARED locks are allowed to continue.
-	_LOCK_PENDING _LockLevel = 3 /* internal use only */
-
-	// An EXCLUSIVE lock is needed in order to write to the database file.
-	// Only one EXCLUSIVE lock is allowed on the file and no other locks of any
-	// kind are allowed to coexist with an EXCLUSIVE lock.
-	// In order to maximize concurrency, SQLite works to minimize the amount of
-	// time that EXCLUSIVE locks are held.
-	_LOCK_EXCLUSIVE _LockLevel = 4 /* xLock() only */
-)
-
-// https://www.sqlite.org/c3ref/c_fcntl_begin_atomic_write.html
-type _FcntlOpcode uint32
-
-const (
-	_FCNTL_LOCKSTATE             _FcntlOpcode = 1
-	_FCNTL_GET_LOCKPROXYFILE     _FcntlOpcode = 2
-	_FCNTL_SET_LOCKPROXYFILE     _FcntlOpcode = 3
-	_FCNTL_LAST_ERRNO            _FcntlOpcode = 4
-	_FCNTL_SIZE_HINT             _FcntlOpcode = 5
-	_FCNTL_CHUNK_SIZE            _FcntlOpcode = 6
-	_FCNTL_FILE_POINTER          _FcntlOpcode = 7
-	_FCNTL_SYNC_OMITTED          _FcntlOpcode = 8
-	_FCNTL_WIN32_AV_RETRY        _FcntlOpcode = 9
-	_FCNTL_PERSIST_WAL           _FcntlOpcode = 10
-	_FCNTL_OVERWRITE             _FcntlOpcode = 11
-	_FCNTL_VFSNAME               _FcntlOpcode = 12
-	_FCNTL_POWERSAFE_OVERWRITE   _FcntlOpcode = 13
-	_FCNTL_PRAGMA                _FcntlOpcode = 14
-	_FCNTL_BUSYHANDLER           _FcntlOpcode = 15
-	_FCNTL_TEMPFILENAME          _FcntlOpcode = 16
-	_FCNTL_MMAP_SIZE             _FcntlOpcode = 18
-	_FCNTL_TRACE                 _FcntlOpcode = 19
-	_FCNTL_HAS_MOVED             _FcntlOpcode = 20
-	_FCNTL_SYNC                  _FcntlOpcode = 21
-	_FCNTL_COMMIT_PHASETWO       _FcntlOpcode = 22
-	_FCNTL_WIN32_SET_HANDLE      _FcntlOpcode = 23
-	_FCNTL_WAL_BLOCK             _FcntlOpcode = 24
-	_FCNTL_ZIPVFS                _FcntlOpcode = 25
-	_FCNTL_RBU                   _FcntlOpcode = 26
-	_FCNTL_VFS_POINTER           _FcntlOpcode = 27
-	_FCNTL_JOURNAL_POINTER       _FcntlOpcode = 28
-	_FCNTL_WIN32_GET_HANDLE      _FcntlOpcode = 29
-	_FCNTL_PDB                   _FcntlOpcode = 30
-	_FCNTL_BEGIN_ATOMIC_WRITE    _FcntlOpcode = 31
-	_FCNTL_COMMIT_ATOMIC_WRITE   _FcntlOpcode = 32
-	_FCNTL_ROLLBACK_ATOMIC_WRITE _FcntlOpcode = 33
-	_FCNTL_LOCK_TIMEOUT          _FcntlOpcode = 34
-	_FCNTL_DATA_VERSION          _FcntlOpcode = 35
-	_FCNTL_SIZE_LIMIT            _FcntlOpcode = 36
-	_FCNTL_CKPT_DONE             _FcntlOpcode = 37
-	_FCNTL_RESERVE_BYTES         _FcntlOpcode = 38
-	_FCNTL_CKPT_START            _FcntlOpcode = 39
-	_FCNTL_EXTERNAL_READER       _FcntlOpcode = 40
-	_FCNTL_CKSM_FILE             _FcntlOpcode = 41
-	_FCNTL_RESET_CACHE           _FcntlOpcode = 42
-)
-
-// https://www.sqlite.org/c3ref/c_iocap_atomic.html
-type _DeviceCharacteristic uint32
-
-const (
-	_IOCAP_ATOMIC                _DeviceCharacteristic = 0x00000001
-	_IOCAP_ATOMIC512             _DeviceCharacteristic = 0x00000002
-	_IOCAP_ATOMIC1K              _DeviceCharacteristic = 0x00000004
-	_IOCAP_ATOMIC2K              _DeviceCharacteristic = 0x00000008
-	_IOCAP_ATOMIC4K              _DeviceCharacteristic = 0x00000010
-	_IOCAP_ATOMIC8K              _DeviceCharacteristic = 0x00000020
-	_IOCAP_ATOMIC16K             _DeviceCharacteristic = 0x00000040
-	_IOCAP_ATOMIC32K             _DeviceCharacteristic = 0x00000080
-	_IOCAP_ATOMIC64K             _DeviceCharacteristic = 0x00000100
-	_IOCAP_SAFE_APPEND           _DeviceCharacteristic = 0x00000200
-	_IOCAP_SEQUENTIAL            _DeviceCharacteristic = 0x00000400
-	_IOCAP_UNDELETABLE_WHEN_OPEN _DeviceCharacteristic = 0x00000800
-	_IOCAP_POWERSAFE_OVERWRITE   _DeviceCharacteristic = 0x00001000
-	_IOCAP_IMMUTABLE             _DeviceCharacteristic = 0x00002000
-	_IOCAP_BATCH_ATOMIC          _DeviceCharacteristic = 0x00004000
-)

internal/vfs/tests/mptest/testdata/main.c

@@ -1,22 +0,0 @@
-#include <stdbool.h>
-#include <stddef.h>
-
-#include "sqlite3.c"
-//
-#include "os.c"
-
-sqlite3_destructor_type malloc_destructor = &free;
-size_t sqlite3_interrupt_offset = offsetof(sqlite3, u1.isInterrupted);
-
-int sqlite3_os_init() {
-  return sqlite3_vfs_register(os_vfs(), /*default=*/true);
-}
-
-__attribute__((constructor)) void premain() { sqlite3_initialize(); }
-
-static int dont_unlink(const char *pathname) { return 0; }
-#define sqlite3_enable_load_extension(...)
-#define sqlite3_trace(...)
-#define unlink dont_unlink
-#undef UNUSED_PARAMETER
-#include "mptest.c"

internal/vfs/tests/mptest/testdata/mptest.wasm

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:37ceeed293b9f09e9770b40eda3f625447f5a3a74208709886d4411d12f93414
-size 1486113

internal/vfs/tests/speedtest1/testdata/main.c

@@ -1,16 +0,0 @@
-#include <stdbool.h>
-#include <stddef.h>
-
-#include "sqlite3.c"
-//
-#include "os.c"
-
-sqlite3_destructor_type malloc_destructor = &free;
-size_t sqlite3_interrupt_offset = offsetof(sqlite3, u1.isInterrupted);
-
-int sqlite3_os_init() {
-  return sqlite3_vfs_register(os_vfs(), /*default=*/true);
-}
-
-#define randomFunc(args...) randomFunc2(args)
-#include "speedtest1.c"

internal/vfs/tests/speedtest1/testdata/speedtest1.wasm

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8167119c344a68217b0301e2e8c288f2e75611d296d7822f841b65911da0275c
-size 1520569

internal/vfs/vfs.go

@@ -1,390 +0,0 @@
-package vfs
-
-import (
-	"context"
-	"crypto/rand"
-	"errors"
-	"io"
-	"io/fs"
-	"os"
-	"path/filepath"
-	"runtime"
-	"time"
-
-	"github.com/ncruces/go-sqlite3/internal/util"
-	"github.com/ncruces/julianday"
-	"github.com/tetratelabs/wazero"
-	"github.com/tetratelabs/wazero/api"
-)
-
-func Export(env wazero.HostModuleBuilder) wazero.HostModuleBuilder {
-	util.RegisterFuncIIJ(env, "os_localtime", vfsLocaltime)
-	util.RegisterFuncIIII(env, "os_randomness", vfsRandomness)
-	util.RegisterFuncIII(env, "os_sleep", vfsSleep)
-	util.RegisterFuncIII(env, "os_current_time", vfsCurrentTime)
-	util.RegisterFuncIII(env, "os_current_time_64", vfsCurrentTime64)
-	util.RegisterFuncIIIII(env, "os_full_pathname", vfsFullPathname)
-	util.RegisterFuncIIII(env, "os_delete", vfsDelete)
-	util.RegisterFuncIIIII(env, "os_access", vfsAccess)
-	util.RegisterFuncIIIIII(env, "os_open", vfsOpen)
-	util.RegisterFuncII(env, "os_close", vfsClose)
-	util.RegisterFuncIIIIJ(env, "os_read", vfsRead)
-	util.RegisterFuncIIIIJ(env, "os_write", vfsWrite)
-	util.RegisterFuncIIJ(env, "os_truncate", vfsTruncate)
-	util.RegisterFuncIII(env, "os_sync", vfsSync)
-	util.RegisterFuncIII(env, "os_file_size", vfsFileSize)
-	util.RegisterFuncIIII(env, "os_file_control", vfsFileControl)
-	util.RegisterFuncII(env, "os_sector_size", vfsSectorSize)
-	util.RegisterFuncII(env, "os_device_characteristics", vfsDeviceCharacteristics)
-	util.RegisterFuncIII(env, "os_lock", vfsLock)
-	util.RegisterFuncIII(env, "os_unlock", vfsUnlock)
-	util.RegisterFuncIII(env, "os_check_reserved_lock", vfsCheckReservedLock)
-	return env
-}
-
-type vfsKey struct{}
-type vfsState struct {
-	files []vfsFile
-}
-
-func Context(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.File != nil {
-			f.Close()
-		}
-	}
-	vfs.files = nil
-	return nil
-}
-
-func vfsLocaltime(ctx context.Context, mod api.Module, pTm uint32, t int64) _ErrorCode {
-	tm := time.Unix(t, 0)
-	var isdst int
-	if tm.IsDST() {
-		isdst = 1
-	}
-
-	const size = 32 / 8
-	// https://pubs.opengroup.org/onlinepubs/7908799/xsh/time.h.html
-	util.WriteUint32(mod, pTm+0*size, uint32(tm.Second()))
-	util.WriteUint32(mod, pTm+1*size, uint32(tm.Minute()))
-	util.WriteUint32(mod, pTm+2*size, uint32(tm.Hour()))
-	util.WriteUint32(mod, pTm+3*size, uint32(tm.Day()))
-	util.WriteUint32(mod, pTm+4*size, uint32(tm.Month()-time.January))
-	util.WriteUint32(mod, pTm+5*size, uint32(tm.Year()-1900))
-	util.WriteUint32(mod, pTm+6*size, uint32(tm.Weekday()-time.Sunday))
-	util.WriteUint32(mod, pTm+7*size, uint32(tm.YearDay()-1))
-	util.WriteUint32(mod, pTm+8*size, uint32(isdst))
-	return _OK
-}
-
-func vfsRandomness(ctx context.Context, mod api.Module, pVfs, nByte, zByte uint32) uint32 {
-	mem := util.View(mod, zByte, uint64(nByte))
-	n, _ := rand.Reader.Read(mem)
-	return uint32(n)
-}
-
-func vfsSleep(ctx context.Context, mod api.Module, pVfs, nMicro uint32) _ErrorCode {
-	time.Sleep(time.Duration(nMicro) * time.Microsecond)
-	return _OK
-}
-
-func vfsCurrentTime(ctx context.Context, mod api.Module, pVfs, prNow uint32) _ErrorCode {
-	day := julianday.Float(time.Now())
-	util.WriteFloat64(mod, prNow, day)
-	return _OK
-}
-
-func vfsCurrentTime64(ctx context.Context, mod api.Module, pVfs, piNow uint32) _ErrorCode {
-	day, nsec := julianday.Date(time.Now())
-	msec := day*86_400_000 + nsec/1_000_000
-	util.WriteUint64(mod, piNow, uint64(msec))
-	return _OK
-}
-
-func vfsFullPathname(ctx context.Context, mod api.Module, pVfs, zRelative, nFull, zFull uint32) _ErrorCode {
-	rel := util.ReadString(mod, zRelative, _MAX_PATHNAME)
-	abs, err := filepath.Abs(rel)
-	if err != nil {
-		return _CANTOPEN_FULLPATH
-	}
-
-	size := uint64(len(abs) + 1)
-	if size > uint64(nFull) {
-		return _CANTOPEN_FULLPATH
-	}
-	mem := util.View(mod, zFull, size)
-	mem[len(abs)] = 0
-	copy(mem, abs)
-
-	if fi, err := os.Lstat(abs); err == nil {
-		if fi.Mode()&fs.ModeSymlink != 0 {
-			return _OK_SYMLINK
-		}
-		return _OK
-	} else if errors.Is(err, fs.ErrNotExist) {
-		return _OK
-	}
-	return _CANTOPEN_FULLPATH
-}
-
-func vfsDelete(ctx context.Context, mod api.Module, pVfs, zPath, syncDir uint32) _ErrorCode {
-	path := util.ReadString(mod, zPath, _MAX_PATHNAME)
-	err := os.Remove(path)
-	if errors.Is(err, fs.ErrNotExist) {
-		return _IOERR_DELETE_NOENT
-	}
-	if err != nil {
-		return _IOERR_DELETE
-	}
-	if runtime.GOOS != "windows" && syncDir != 0 {
-		f, err := os.Open(filepath.Dir(path))
-		if err != nil {
-			return _OK
-		}
-		defer f.Close()
-		err = osSync(f, false, false)
-		if err != nil {
-			return _IOERR_DIR_FSYNC
-		}
-	}
-	return _OK
-}
-
-func vfsAccess(ctx context.Context, mod api.Module, pVfs, zPath uint32, flags _AccessFlag, pResOut uint32) _ErrorCode {
-	path := util.ReadString(mod, zPath, _MAX_PATHNAME)
-	err := osAccess(path, flags)
-
-	var res uint32
-	var rc _ErrorCode
-	if flags == _ACCESS_EXISTS {
-		switch {
-		case err == nil:
-			res = 1
-		case errors.Is(err, fs.ErrNotExist):
-			res = 0
-		default:
-			rc = _IOERR_ACCESS
-		}
-	} else {
-		switch {
-		case err == nil:
-			res = 1
-		case errors.Is(err, fs.ErrPermission):
-			res = 0
-		default:
-			rc = _IOERR_ACCESS
-		}
-	}
-
-	util.WriteUint32(mod, pResOut, res)
-	return rc
-}
-
-func vfsOpen(ctx context.Context, mod api.Module, pVfs, zName, pFile uint32, flags _OpenFlag, pOutFlags uint32) _ErrorCode {
-	var oflags int
-	if flags&_OPEN_EXCLUSIVE != 0 {
-		oflags |= os.O_EXCL
-	}
-	if flags&_OPEN_CREATE != 0 {
-		oflags |= os.O_CREATE
-	}
-	if flags&_OPEN_READONLY != 0 {
-		oflags |= os.O_RDONLY
-	}
-	if flags&_OPEN_READWRITE != 0 {
-		oflags |= os.O_RDWR
-	}
-
-	var err error
-	var f *os.File
-	if zName == 0 {
-		f, err = os.CreateTemp("", "*.db")
-	} else {
-		name := util.ReadString(mod, zName, _MAX_PATHNAME)
-		f, err = osOpenFile(name, oflags, 0666)
-	}
-	if err != nil {
-		return _CANTOPEN
-	}
-
-	if flags&_OPEN_DELETEONCLOSE != 0 {
-		os.Remove(f.Name())
-	}
-
-	file := openVFSFile(ctx, mod, pFile, f)
-	file.psow = true
-	file.readOnly = flags&_OPEN_READONLY != 0
-	file.syncDir = runtime.GOOS != "windows" &&
-		flags&(_OPEN_CREATE) != 0 &&
-		flags&(_OPEN_MAIN_JOURNAL|_OPEN_SUPER_JOURNAL|_OPEN_WAL) != 0
-
-	if pOutFlags != 0 {
-		util.WriteUint32(mod, pOutFlags, uint32(flags))
-	}
-	return _OK
-}
-
-func vfsClose(ctx context.Context, mod api.Module, pFile uint32) _ErrorCode {
-	err := closeVFSFile(ctx, mod, pFile)
-	if err != nil {
-		return _IOERR_CLOSE
-	}
-	return _OK
-}
-
-func vfsRead(ctx context.Context, mod api.Module, pFile, zBuf, iAmt uint32, iOfst int64) _ErrorCode {
-	buf := util.View(mod, zBuf, uint64(iAmt))
-
-	file := getVFSFile(ctx, mod, pFile)
-	n, err := file.ReadAt(buf, iOfst)
-	if n == int(iAmt) {
-		return _OK
-	}
-	if n == 0 && err != io.EOF {
-		return _IOERR_READ
-	}
-	for i := range buf[n:] {
-		buf[n+i] = 0
-	}
-	return _IOERR_SHORT_READ
-}
-
-func vfsWrite(ctx context.Context, mod api.Module, pFile, zBuf, iAmt uint32, iOfst int64) _ErrorCode {
-	buf := util.View(mod, zBuf, uint64(iAmt))
-
-	file := getVFSFile(ctx, mod, pFile)
-	_, err := file.WriteAt(buf, iOfst)
-	if err != nil {
-		return _IOERR_WRITE
-	}
-	return _OK
-}
-
-func vfsTruncate(ctx context.Context, mod api.Module, pFile uint32, nByte int64) _ErrorCode {
-	file := getVFSFile(ctx, mod, pFile)
-	err := file.Truncate(nByte)
-	if err != nil {
-		return _IOERR_TRUNCATE
-	}
-	return _OK
-}
-
-func vfsSync(ctx context.Context, mod api.Module, pFile uint32, flags _SyncFlag) _ErrorCode {
-	dataonly := (flags & _SYNC_DATAONLY) != 0
-	fullsync := (flags & 0x0f) == _SYNC_FULL
-
-	file := getVFSFile(ctx, mod, pFile)
-	err := osSync(file.File, fullsync, dataonly)
-	if err != nil {
-		return _IOERR_FSYNC
-	}
-	if runtime.GOOS != "windows" && file.syncDir {
-		file.syncDir = false
-		f, err := os.Open(filepath.Dir(file.Name()))
-		if err != nil {
-			return _OK
-		}
-		defer f.Close()
-		err = osSync(f, false, false)
-		if err != nil {
-			return _IOERR_DIR_FSYNC
-		}
-	}
-	return _OK
-}
-
-func vfsFileSize(ctx context.Context, mod api.Module, pFile, pSize uint32) _ErrorCode {
-	file := getVFSFile(ctx, mod, pFile)
-	off, err := file.Seek(0, io.SeekEnd)
-	if err != nil {
-		return _IOERR_SEEK
-	}
-
-	util.WriteUint64(mod, pSize, uint64(off))
-	return _OK
-}
-
-func vfsFileControl(ctx context.Context, mod api.Module, pFile uint32, op _FcntlOpcode, pArg uint32) _ErrorCode {
-	switch op {
-	case _FCNTL_LOCKSTATE:
-		util.WriteUint32(mod, pArg, uint32(getVFSFile(ctx, mod, pFile).lock))
-		return _OK
-	case _FCNTL_LOCK_TIMEOUT:
-		file := getVFSFile(ctx, mod, pFile)
-		millis := file.lockTimeout.Milliseconds()
-		file.lockTimeout = time.Duration(util.ReadUint32(mod, pArg)) * time.Millisecond
-		util.WriteUint32(mod, pArg, uint32(millis))
-		return _OK
-	case _FCNTL_POWERSAFE_OVERWRITE:
-		file := getVFSFile(ctx, mod, pFile)
-		switch util.ReadUint32(mod, pArg) {
-		case 0:
-			file.psow = false
-		case 1:
-			file.psow = true
-		default:
-			if file.psow {
-				util.WriteUint32(mod, pArg, 1)
-			} else {
-				util.WriteUint32(mod, pArg, 0)
-			}
-		}
-	case _FCNTL_SIZE_HINT:
-		return vfsSizeHint(ctx, mod, pFile, pArg)
-	case _FCNTL_HAS_MOVED:
-		return vfsFileMoved(ctx, mod, pFile, pArg)
-	}
-	// Consider also implementing these opcodes (in use by SQLite):
-	//  _FCNTL_BUSYHANDLER
-	//  _FCNTL_COMMIT_PHASETWO
-	//  _FCNTL_PDB
-	//  _FCNTL_PRAGMA
-	//  _FCNTL_SYNC
-	return _NOTFOUND
-}
-
-func vfsSectorSize(ctx context.Context, mod api.Module, pFile uint32) uint32 {
-	return _DEFAULT_SECTOR_SIZE
-}
-
-func vfsDeviceCharacteristics(ctx context.Context, mod api.Module, pFile uint32) _DeviceCharacteristic {
-	file := getVFSFile(ctx, mod, pFile)
-	if file.psow {
-		return _IOCAP_POWERSAFE_OVERWRITE
-	}
-	return 0
-}
-
-func vfsSizeHint(ctx context.Context, mod api.Module, pFile, pArg uint32) _ErrorCode {
-	file := getVFSFile(ctx, mod, pFile)
-	size := util.ReadUint64(mod, pArg)
-	err := osAllocate(file.File, int64(size))
-	if err != nil {
-		return _IOERR_TRUNCATE
-	}
-	return _OK
-}
-
-func vfsFileMoved(ctx context.Context, mod api.Module, pFile, pResOut uint32) _ErrorCode {
-	file := getVFSFile(ctx, mod, pFile)
-	fi, err := file.Stat()
-	if err != nil {
-		return _IOERR_FSTAT
-	}
-	pi, err := os.Stat(file.Name())
-	if err != nil && !errors.Is(err, fs.ErrNotExist) {
-		return _IOERR_FSTAT
-	}
-	var res uint32
-	if !os.SameFile(fi, pi) {
-		res = 1
-	}
-	util.WriteUint32(mod, pResOut, res)
-	return _OK
-}

internal/vfs/vfs_file.go

@@ -1,54 +0,0 @@
-package vfs
-
-import (
-	"context"
-	"os"
-	"time"
-
-	"github.com/ncruces/go-sqlite3/internal/util"
-	"github.com/tetratelabs/wazero/api"
-)
-
-type vfsFile struct {
-	*os.File
-	lockTimeout time.Duration
-	lock        _LockLevel
-	psow        bool
-	syncDir     bool
-	readOnly    bool
-}
-
-func newVFSFile(vfs *vfsState, file *os.File) uint32 {
-	// Find an empty slot.
-	for id, f := range vfs.files {
-		if f.File == nil {
-			vfs.files[id] = vfsFile{File: file}
-			return uint32(id)
-		}
-	}
-
-	// Add a new slot.
-	vfs.files = append(vfs.files, vfsFile{File: file})
-	return uint32(len(vfs.files) - 1)
-}
-
-func getVFSFile(ctx context.Context, mod api.Module, pFile uint32) *vfsFile {
-	vfs := ctx.Value(vfsKey{}).(*vfsState)
-	id := util.ReadUint32(mod, pFile+4)
-	return &vfs.files[id]
-}
-
-func openVFSFile(ctx context.Context, mod api.Module, pFile uint32, file *os.File) *vfsFile {
-	vfs := ctx.Value(vfsKey{}).(*vfsState)
-	id := newVFSFile(vfs, file)
-	util.WriteUint32(mod, pFile+4, id)
-	return &vfs.files[id]
-}
-
-func closeVFSFile(ctx context.Context, mod api.Module, pFile uint32) error {
-	vfs := ctx.Value(vfsKey{}).(*vfsState)
-	id := util.ReadUint32(mod, pFile+4)
-	file := vfs.files[id]
-	vfs.files[id] = vfsFile{}
-	return file.Close()
-}

module.go

@@ -9,7 +9,7 @@ import (
 	"sync"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
-	"github.com/ncruces/go-sqlite3/internal/vfs"
+	"github.com/ncruces/go-sqlite3/sqlite3vfs"
 	"github.com/tetratelabs/wazero"
 	"github.com/tetratelabs/wazero/api"
 )
@@ -53,7 +53,7 @@ func compileModule() {
 	ctx := context.Background()
 	sqlite3.runtime = wazero.NewRuntime(ctx)
 
-	env := vfs.Export(sqlite3.runtime.NewHostModuleBuilder("env"))
+	env := sqlite3vfs.ExportHostFunctions(sqlite3.runtime.NewHostModuleBuilder("env"))
 	_, sqlite3.err = env.Instantiate(ctx)
 	if sqlite3.err != nil {
 		return
@@ -85,7 +85,7 @@ type module struct {
 func newModule(mod api.Module) (m *module, err error) {
 	m = &module{}
 	m.mod = mod
-	m.ctx, m.vfs = vfs.Context(context.Background())
+	m.ctx, m.vfs = sqlite3vfs.NewContext(context.Background())
 
 	getFun := func(name string) api.Function {
 		f := mod.ExportedFunction(name)
@@ -153,7 +153,6 @@ func newModule(mod api.Module) (m *module, err error) {
 		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
@@ -356,5 +355,4 @@ type sqliteAPI struct {
 	backupRemaining api.Function
 	backupPageCount api.Function
 	destructor      uint32
-	interrupt       uint32
 }

sqlite3/download.sh

@@ -3,29 +3,29 @@ set -euo pipefail
 
 cd -P -- "$(dirname -- "$0")"
 
-curl -#OL "https://sqlite.org/2023/sqlite-amalgamation-3410200.zip"
+curl -#OL "https://sqlite.org/2023/sqlite-amalgamation-3420000.zip"
 unzip -d . sqlite-amalgamation-*.zip
 mv sqlite-amalgamation-*/sqlite3* .
 rm -rf sqlite-amalgamation-*
 
 cd ext/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.2/ext/misc/decimal.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.2/ext/misc/uint.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.2/ext/misc/uuid.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.2/ext/misc/base64.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.2/ext/misc/regexp.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.2/ext/misc/series.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.42.0/ext/misc/decimal.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.42.0/ext/misc/uint.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.42.0/ext/misc/uuid.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.42.0/ext/misc/base64.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.42.0/ext/misc/regexp.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.42.0/ext/misc/series.c"
 cd ~-
 
-cd ../internal/vfs/tests/mptest/testdata/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.2/mptest/mptest.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.2/mptest/config01.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.2/mptest/config02.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.2/mptest/crash01.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.2/mptest/crash02.subtest"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.2/mptest/multiwrite01.test"
+cd ../sqlite3vfs/tests/mptest/testdata/
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.42.0/mptest/mptest.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.42.0/mptest/config01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.42.0/mptest/config02.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.42.0/mptest/crash01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.42.0/mptest/crash02.subtest"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.42.0/mptest/multiwrite01.test"
 cd ~-
 
-cd ../internal/vfs/tests/speedtest1/testdata/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.2/test/speedtest1.c"
+cd ../sqlite3vfs/tests/speedtest1/testdata/
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.42.0/test/speedtest1.c"
 cd ~-

sqlite3/main.c

@@ -1,10 +1,13 @@
 #include <stdbool.h>
 #include <stddef.h>
 
+// Configuration
+#include "sqlite_cfg.h"
+// Amalgamation
 #include "sqlite3.c"
-//
-#include "os.c"
-//
+// VFS
+#include "vfs.c"
+// Extensions
 #include "ext/base64.c"
 #include "ext/decimal.c"
 #include "ext/regexp.c"
@@ -13,13 +16,6 @@
 #include "ext/uuid.c"
 #include "time.c"
 
-sqlite3_destructor_type malloc_destructor = &free;
-size_t sqlite3_interrupt_offset = offsetof(sqlite3, u1.isInterrupted);
-
-int sqlite3_os_init() {
-  return sqlite3_vfs_register(os_vfs(), /*default=*/true);
-}
-
 __attribute__((constructor)) void init() {
   sqlite3_initialize();
   sqlite3_auto_extension((void (*)(void))sqlite3_base_init);

sqlite3/os.c

@@ -1,97 +0,0 @@
-#include <time.h>
-
-#include "sqlite3.h"
-
-int os_localtime(struct tm *, sqlite3_int64);
-
-int os_randomness(sqlite3_vfs *, int nByte, char *zOut);
-int os_sleep(sqlite3_vfs *, int microseconds);
-int os_current_time(sqlite3_vfs *, double *);
-int os_current_time_64(sqlite3_vfs *, sqlite3_int64 *);
-
-int os_open(sqlite3_vfs *, sqlite3_filename zName, sqlite3_file *, int flags,
-            int *pOutFlags);
-int os_delete(sqlite3_vfs *, const char *zName, int syncDir);
-int os_access(sqlite3_vfs *, const char *zName, int flags, int *pResOut);
-int os_full_pathname(sqlite3_vfs *, const char *zName, int nOut, char *zOut);
-
-struct os_file {
-  sqlite3_file base;
-  int handle;
-};
-
-static_assert(offsetof(struct os_file, handle) == 4, "Unexpected offset");
-
-int os_close(sqlite3_file *);
-int os_read(sqlite3_file *, void *, int iAmt, sqlite3_int64 iOfst);
-int os_write(sqlite3_file *, const void *, int iAmt, sqlite3_int64 iOfst);
-int os_truncate(sqlite3_file *, sqlite3_int64 size);
-int os_sync(sqlite3_file *, int flags);
-int os_file_size(sqlite3_file *, sqlite3_int64 *pSize);
-int os_file_control(sqlite3_file *, int op, void *pArg);
-int os_sector_size(sqlite3_file *file);
-int os_device_characteristics(sqlite3_file *file);
-
-int os_lock(sqlite3_file *, int eLock);
-int os_unlock(sqlite3_file *, int eLock);
-int os_check_reserved_lock(sqlite3_file *, int *pResOut);
-
-static int os_file_control_w(sqlite3_file *file, int op, void *pArg) {
-  struct os_file *pFile = (struct os_file *)file;
-  if (op == SQLITE_FCNTL_VFSNAME) {
-    *(char **)pArg = sqlite3_mprintf("%s", "os");
-    return SQLITE_OK;
-  }
-  return os_file_control(file, op, pArg);
-}
-
-static int os_open_w(sqlite3_vfs *vfs, sqlite3_filename zName,
-                     sqlite3_file *file, int flags, int *pOutFlags) {
-  static const sqlite3_io_methods os_io = {
-      .iVersion = 1,
-      .xClose = os_close,
-      .xRead = os_read,
-      .xWrite = os_write,
-      .xTruncate = os_truncate,
-      .xSync = os_sync,
-      .xFileSize = os_file_size,
-      .xLock = os_lock,
-      .xUnlock = os_unlock,
-      .xCheckReservedLock = os_check_reserved_lock,
-      .xFileControl = os_file_control_w,
-      .xSectorSize = os_sector_size,
-      .xDeviceCharacteristics = os_device_characteristics,
-  };
-  memset(file, 0, sizeof(struct os_file));
-  int rc = os_open(vfs, zName, file, flags, pOutFlags);
-  if (rc) {
-    return rc;
-  }
-
-  file->pMethods = &os_io;
-  return SQLITE_OK;
-}
-
-sqlite3_vfs *os_vfs() {
-  static sqlite3_vfs os_vfs = {
-      .iVersion = 2,
-      .szOsFile = sizeof(struct os_file),
-      .mxPathname = 512,
-      .zName = "os",
-
-      .xOpen = os_open_w,
-      .xDelete = os_delete,
-      .xAccess = os_access,
-      .xFullPathname = os_full_pathname,
-
-      .xRandomness = os_randomness,
-      .xSleep = os_sleep,
-      .xCurrentTime = os_current_time,
-      .xCurrentTimeInt64 = os_current_time_64,
-  };
-  return &os_vfs;
-}
-
-int localtime_s(struct tm *const pTm, time_t const *const pTime) {
-  return os_localtime(pTm, (sqlite3_int64)*pTime);
-}

sqlite3/sqlite_cfg.h

@@ -29,7 +29,7 @@
 #define SQLITE_USE_ALLOCA
 
 // Other Options
-// #define SQLITE_ALLOW_URI_AUTHORITY
+#define SQLITE_ALLOW_URI_AUTHORITY
 
 // Because WASM does not support shared memory,
 // SQLite disables WAL for WASM builds.
@@ -40,7 +40,7 @@
 #define SQLITE_DEFAULT_LOCKING_MODE 1
 #endif
 
-// Recommended Extensions
+// Amalgamated Extensions
 
 #define SQLITE_ENABLE_MATH_FUNCTIONS 1
 #define SQLITE_ENABLE_JSON1 1
@@ -52,8 +52,19 @@
 #define SQLITE_ENABLE_GEOPOLY 1
 
 // Session Extension
-// #define SQLITE_ENABLE_SESSION 1
-// #define SQLITE_ENABLE_PREUPDATE_HOOK 1
+// #define SQLITE_ENABLE_SESSION
+// #define SQLITE_ENABLE_PREUPDATE_HOOK
 
-// Implemented in Go.
-int localtime_s(struct tm *const pTm, time_t const *const pTime);
+// https://stackoverflow.com/a/50616684
+#define SECOND(...) SECOND_I(__VA_ARGS__, , )
+#define SECOND_I(A, B, ...) B
+#define GLUE(A, B) GLUE_I(A, B)
+#define GLUE_I(A, B) A##_##B
+#define CREATE_REPLACER(A) SECOND(GLUE(A, __LINE__), A)
+#define REPLACE_AT_LINE(A) , A
+
+// Implemented in vfs.c.
+int localtime_s(struct tm *const pTm, time_t const *const pTime);
+
+#define sqlite3_vfs_find CREATE_REPLACER(sqlite3_vfs_find_wrapper)
+#define sqlite3_vfs_find_wrapper_25397 REPLACE_AT_LINE(sqlite3_vfs_find)

sqlite3/vfs.c

@@ -0,0 +1,138 @@
+#include <time.h>
+
+#include "sqlite3.h"
+
+int go_localtime(struct tm *, sqlite3_int64);
+int go_vfs_find(const char *zVfsName);
+
+int go_randomness(sqlite3_vfs *, int nByte, char *zOut);
+int go_sleep(sqlite3_vfs *, int microseconds);
+int go_current_time(sqlite3_vfs *, double *);
+int go_current_time_64(sqlite3_vfs *, sqlite3_int64 *);
+
+int go_open(sqlite3_vfs *, sqlite3_filename zName, sqlite3_file *, int flags,
+            int *pOutFlags);
+int go_delete(sqlite3_vfs *, const char *zName, int syncDir);
+int go_access(sqlite3_vfs *, const char *zName, int flags, int *pResOut);
+int go_full_pathname(sqlite3_vfs *, const char *zName, int nOut, char *zOut);
+
+int go_close(sqlite3_file *);
+int go_read(sqlite3_file *, void *, int iAmt, sqlite3_int64 iOfst);
+int go_write(sqlite3_file *, const void *, int iAmt, sqlite3_int64 iOfst);
+int go_truncate(sqlite3_file *, sqlite3_int64 size);
+int go_sync(sqlite3_file *, int flags);
+int go_file_size(sqlite3_file *, sqlite3_int64 *pSize);
+int go_file_control(sqlite3_file *, int op, void *pArg);
+int go_sector_size(sqlite3_file *file);
+int go_device_characteristics(sqlite3_file *file);
+
+int go_lock(sqlite3_file *, int eLock);
+int go_unlock(sqlite3_file *, int eLock);
+int go_check_reserved_lock(sqlite3_file *, int *pResOut);
+
+static int go_open_wrapper(sqlite3_vfs *vfs, sqlite3_filename zName,
+                           sqlite3_file *file, int flags, int *pOutFlags) {
+  static const sqlite3_io_methods os_io = {
+      .iVersion = 1,
+      .xClose = go_close,
+      .xRead = go_read,
+      .xWrite = go_write,
+      .xTruncate = go_truncate,
+      .xSync = go_sync,
+      .xFileSize = go_file_size,
+      .xLock = go_lock,
+      .xUnlock = go_unlock,
+      .xCheckReservedLock = go_check_reserved_lock,
+      .xFileControl = go_file_control,
+      .xSectorSize = go_sector_size,
+      .xDeviceCharacteristics = go_device_characteristics,
+  };
+  memset(file, 0, vfs->szOsFile);
+  int rc = go_open(vfs, zName, file, flags, pOutFlags);
+  if (rc) {
+    return rc;
+  }
+  file->pMethods = &os_io;
+  return SQLITE_OK;
+}
+
+struct go_file {
+  sqlite3_file base;
+  int handle;
+};
+
+int sqlite3_os_init() {
+  static sqlite3_vfs os_vfs = {
+      .iVersion = 2,
+      .szOsFile = sizeof(struct go_file),
+      .mxPathname = 512,
+      .zName = "os",
+
+      .xOpen = go_open_wrapper,
+      .xDelete = go_delete,
+      .xAccess = go_access,
+      .xFullPathname = go_full_pathname,
+
+      .xRandomness = go_randomness,
+      .xSleep = go_sleep,
+      .xCurrentTime = go_current_time,
+      .xCurrentTimeInt64 = go_current_time_64,
+  };
+  return sqlite3_vfs_register(&os_vfs, /*default=*/true);
+}
+
+sqlite3_destructor_type malloc_destructor = &free;
+
+int localtime_s(struct tm *const pTm, time_t const *const pTime) {
+  return go_localtime(pTm, (sqlite3_int64)*pTime);
+}
+
+#undef sqlite3_vfs_find
+sqlite3_vfs *sqlite3_vfs_find_wrapper(const char *zVfsName) {
+  if (zVfsName) {
+    static sqlite3_vfs *go_vfs_list;
+    sqlite3_vfs *found = NULL;
+    for (sqlite3_vfs **next = &go_vfs_list; *next;) {
+      sqlite3_vfs *it = *next;
+      if (go_vfs_find(it->zName)) {
+        if (!strcmp(zVfsName, it->zName)) found = it;
+        next = &it->pNext;
+      } else {
+        *next = it->pNext;
+        free(it);
+      }
+    }
+    if (found) {
+      return found;
+    }
+    if (go_vfs_find(zVfsName)) {
+      sqlite3_vfs *prev = go_vfs_list;
+      go_vfs_list = malloc(sizeof(sqlite3_vfs) + strlen(zVfsName) + 1);
+      char *name = (char *)(go_vfs_list + 1);
+      strcpy(name, zVfsName);
+      *go_vfs_list = (sqlite3_vfs){
+          .iVersion = 2,
+          .szOsFile = sizeof(struct go_file),
+          .mxPathname = 512,
+          .zName = name,
+          .pNext = prev,
+
+          .xOpen = go_open_wrapper,
+          .xDelete = go_delete,
+          .xAccess = go_access,
+          .xFullPathname = go_full_pathname,
+
+          .xRandomness = go_randomness,
+          .xSleep = go_sleep,
+          .xCurrentTime = go_current_time,
+          .xCurrentTimeInt64 = go_current_time_64,
+      };
+      return go_vfs_list;
+    }
+  }
+  return sqlite3_vfs_find(zVfsName);
+}
+
+static_assert(offsetof(struct go_file, handle) == 4, "Unexpected offset");
+static_assert(offsetof(sqlite3_vfs, zName) == 16, "Unexpected offset");
+static_assert(offsetof(sqlite3, u1.isInterrupted) == 280, "Unexpected offset");

sqlite3vfs/const.go

@@ -0,0 +1,210 @@
+package sqlite3vfs
+
+import "github.com/ncruces/go-sqlite3/internal/util"
+
+const (
+	_MAX_STRING          = 512 // Used for short strings: names, error messages…
+	_MAX_PATHNAME        = 512
+	_DEFAULT_SECTOR_SIZE = 4096
+)
+
+// https://www.sqlite.org/rescode.html
+type _ErrorCode uint32
+
+func (e _ErrorCode) Error() string {
+	return util.ErrorCodeString(uint32(e))
+}
+
+const (
+	_OK                      _ErrorCode = util.OK
+	_PERM                    _ErrorCode = util.PERM
+	_BUSY                    _ErrorCode = util.BUSY
+	_IOERR                   _ErrorCode = util.IOERR
+	_NOTFOUND                _ErrorCode = util.NOTFOUND
+	_CANTOPEN                _ErrorCode = util.CANTOPEN
+	_IOERR_READ              _ErrorCode = util.IOERR_READ
+	_IOERR_SHORT_READ        _ErrorCode = util.IOERR_SHORT_READ
+	_IOERR_WRITE             _ErrorCode = util.IOERR_WRITE
+	_IOERR_FSYNC             _ErrorCode = util.IOERR_FSYNC
+	_IOERR_DIR_FSYNC         _ErrorCode = util.IOERR_DIR_FSYNC
+	_IOERR_TRUNCATE          _ErrorCode = util.IOERR_TRUNCATE
+	_IOERR_FSTAT             _ErrorCode = util.IOERR_FSTAT
+	_IOERR_UNLOCK            _ErrorCode = util.IOERR_UNLOCK
+	_IOERR_RDLOCK            _ErrorCode = util.IOERR_RDLOCK
+	_IOERR_DELETE            _ErrorCode = util.IOERR_DELETE
+	_IOERR_ACCESS            _ErrorCode = util.IOERR_ACCESS
+	_IOERR_CHECKRESERVEDLOCK _ErrorCode = util.IOERR_CHECKRESERVEDLOCK
+	_IOERR_LOCK              _ErrorCode = util.IOERR_LOCK
+	_IOERR_CLOSE             _ErrorCode = util.IOERR_CLOSE
+	_IOERR_SEEK              _ErrorCode = util.IOERR_SEEK
+	_IOERR_DELETE_NOENT      _ErrorCode = util.IOERR_DELETE_NOENT
+	_CANTOPEN_FULLPATH       _ErrorCode = util.CANTOPEN_FULLPATH
+	_OK_SYMLINK              _ErrorCode = util.OK_SYMLINK
+)
+
+// OpenFlag is a flag for the [VFS] Open method.
+//
+// https://www.sqlite.org/c3ref/c_open_autoproxy.html
+type OpenFlag uint32
+
+const (
+	OPEN_READONLY      OpenFlag = 0x00000001 /* Ok for sqlite3_open_v2() */
+	OPEN_READWRITE     OpenFlag = 0x00000002 /* Ok for sqlite3_open_v2() */
+	OPEN_CREATE        OpenFlag = 0x00000004 /* Ok for sqlite3_open_v2() */
+	OPEN_DELETEONCLOSE OpenFlag = 0x00000008 /* VFS only */
+	OPEN_EXCLUSIVE     OpenFlag = 0x00000010 /* VFS only */
+	OPEN_AUTOPROXY     OpenFlag = 0x00000020 /* VFS only */
+	OPEN_URI           OpenFlag = 0x00000040 /* Ok for sqlite3_open_v2() */
+	OPEN_MEMORY        OpenFlag = 0x00000080 /* Ok for sqlite3_open_v2() */
+	OPEN_MAIN_DB       OpenFlag = 0x00000100 /* VFS only */
+	OPEN_TEMP_DB       OpenFlag = 0x00000200 /* VFS only */
+	OPEN_TRANSIENT_DB  OpenFlag = 0x00000400 /* VFS only */
+	OPEN_MAIN_JOURNAL  OpenFlag = 0x00000800 /* VFS only */
+	OPEN_TEMP_JOURNAL  OpenFlag = 0x00001000 /* VFS only */
+	OPEN_SUBJOURNAL    OpenFlag = 0x00002000 /* VFS only */
+	OPEN_SUPER_JOURNAL OpenFlag = 0x00004000 /* VFS only */
+	OPEN_NOMUTEX       OpenFlag = 0x00008000 /* Ok for sqlite3_open_v2() */
+	OPEN_FULLMUTEX     OpenFlag = 0x00010000 /* Ok for sqlite3_open_v2() */
+	OPEN_SHAREDCACHE   OpenFlag = 0x00020000 /* Ok for sqlite3_open_v2() */
+	OPEN_PRIVATECACHE  OpenFlag = 0x00040000 /* Ok for sqlite3_open_v2() */
+	OPEN_WAL           OpenFlag = 0x00080000 /* VFS only */
+	OPEN_NOFOLLOW      OpenFlag = 0x01000000 /* Ok for sqlite3_open_v2() */
+)
+
+// AccessFlag is a flag for the [VFS] Access method.
+//
+// https://www.sqlite.org/c3ref/c_access_exists.html
+type AccessFlag uint32
+
+const (
+	ACCESS_EXISTS    AccessFlag = 0
+	ACCESS_READWRITE AccessFlag = 1 /* Used by PRAGMA temp_store_directory */
+	ACCESS_READ      AccessFlag = 2 /* Unused */
+)
+
+// SyncFlag is a flag for the [File] Sync method.
+//
+// https://www.sqlite.org/c3ref/c_sync_dataonly.html
+type SyncFlag uint32
+
+const (
+	SYNC_NORMAL   SyncFlag = 0x00002
+	SYNC_FULL     SyncFlag = 0x00003
+	SYNC_DATAONLY SyncFlag = 0x00010
+)
+
+// LockLevel is a value used with [File] Lock and Unlock methods.
+//
+// https://www.sqlite.org/c3ref/c_lock_exclusive.html
+type LockLevel uint32
+
+const (
+	// No locks are held on the database.
+	// The database may be neither read nor written.
+	// Any internally cached data is considered suspect and subject to
+	// verification against the database file before being used.
+	// Other processes can read or write the database as their own locking
+	// states permit.
+	// This is the default state.
+	LOCK_NONE LockLevel = 0 /* xUnlock() only */
+
+	// The database may be read but not written.
+	// Any number of processes can hold SHARED locks at the same time,
+	// hence there can be many simultaneous readers.
+	// But no other thread or process is allowed to write to the database file
+	// while one or more SHARED locks are active.
+	LOCK_SHARED LockLevel = 1 /* xLock() or xUnlock() */
+
+	// A RESERVED lock means that the process is planning on writing to the
+	// database file at some point in the future but that it is currently just
+	// reading from the file.
+	// Only a single RESERVED lock may be active at one time,
+	// though multiple SHARED locks can coexist with a single RESERVED lock.
+	// RESERVED differs from PENDING in that new SHARED locks can be acquired
+	// while there is a RESERVED lock.
+	LOCK_RESERVED LockLevel = 2 /* xLock() only */
+
+	// A PENDING lock means that the process holding the lock wants to write to
+	// the database as soon as possible and is just waiting on all current
+	// SHARED locks to clear so that it can get an EXCLUSIVE lock.
+	// No new SHARED locks are permitted against the database if a PENDING lock
+	// is active, though existing SHARED locks are allowed to continue.
+	LOCK_PENDING LockLevel = 3 /* internal use only */
+
+	// An EXCLUSIVE lock is needed in order to write to the database file.
+	// Only one EXCLUSIVE lock is allowed on the file and no other locks of any
+	// kind are allowed to coexist with an EXCLUSIVE lock.
+	// In order to maximize concurrency, SQLite works to minimize the amount of
+	// time that EXCLUSIVE locks are held.
+	LOCK_EXCLUSIVE LockLevel = 4 /* xLock() only */
+)
+
+// DeviceCharacteristic is a flag retuned by the [File] DeviceCharacteristics method.
+//
+// https://www.sqlite.org/c3ref/c_iocap_atomic.html
+type DeviceCharacteristic uint32
+
+const (
+	IOCAP_ATOMIC                DeviceCharacteristic = 0x00000001
+	IOCAP_ATOMIC512             DeviceCharacteristic = 0x00000002
+	IOCAP_ATOMIC1K              DeviceCharacteristic = 0x00000004
+	IOCAP_ATOMIC2K              DeviceCharacteristic = 0x00000008
+	IOCAP_ATOMIC4K              DeviceCharacteristic = 0x00000010
+	IOCAP_ATOMIC8K              DeviceCharacteristic = 0x00000020
+	IOCAP_ATOMIC16K             DeviceCharacteristic = 0x00000040
+	IOCAP_ATOMIC32K             DeviceCharacteristic = 0x00000080
+	IOCAP_ATOMIC64K             DeviceCharacteristic = 0x00000100
+	IOCAP_SAFE_APPEND           DeviceCharacteristic = 0x00000200
+	IOCAP_SEQUENTIAL            DeviceCharacteristic = 0x00000400
+	IOCAP_UNDELETABLE_WHEN_OPEN DeviceCharacteristic = 0x00000800
+	IOCAP_POWERSAFE_OVERWRITE   DeviceCharacteristic = 0x00001000
+	IOCAP_IMMUTABLE             DeviceCharacteristic = 0x00002000
+	IOCAP_BATCH_ATOMIC          DeviceCharacteristic = 0x00004000
+)
+
+// https://www.sqlite.org/c3ref/c_fcntl_begin_atomic_write.html
+type _FcntlOpcode uint32
+
+const (
+	_FCNTL_LOCKSTATE             _FcntlOpcode = 1
+	_FCNTL_GET_LOCKPROXYFILE     _FcntlOpcode = 2
+	_FCNTL_SET_LOCKPROXYFILE     _FcntlOpcode = 3
+	_FCNTL_LAST_ERRNO            _FcntlOpcode = 4
+	_FCNTL_SIZE_HINT             _FcntlOpcode = 5
+	_FCNTL_CHUNK_SIZE            _FcntlOpcode = 6
+	_FCNTL_FILE_POINTER          _FcntlOpcode = 7
+	_FCNTL_SYNC_OMITTED          _FcntlOpcode = 8
+	_FCNTL_WIN32_AV_RETRY        _FcntlOpcode = 9
+	_FCNTL_PERSIST_WAL           _FcntlOpcode = 10
+	_FCNTL_OVERWRITE             _FcntlOpcode = 11
+	_FCNTL_VFSNAME               _FcntlOpcode = 12
+	_FCNTL_POWERSAFE_OVERWRITE   _FcntlOpcode = 13
+	_FCNTL_PRAGMA                _FcntlOpcode = 14
+	_FCNTL_BUSYHANDLER           _FcntlOpcode = 15
+	_FCNTL_TEMPFILENAME          _FcntlOpcode = 16
+	_FCNTL_MMAP_SIZE             _FcntlOpcode = 18
+	_FCNTL_TRACE                 _FcntlOpcode = 19
+	_FCNTL_HAS_MOVED             _FcntlOpcode = 20
+	_FCNTL_SYNC                  _FcntlOpcode = 21
+	_FCNTL_COMMIT_PHASETWO       _FcntlOpcode = 22
+	_FCNTL_WIN32_SET_HANDLE      _FcntlOpcode = 23
+	_FCNTL_WAL_BLOCK             _FcntlOpcode = 24
+	_FCNTL_ZIPVFS                _FcntlOpcode = 25
+	_FCNTL_RBU                   _FcntlOpcode = 26
+	_FCNTL_VFS_POINTER           _FcntlOpcode = 27
+	_FCNTL_JOURNAL_POINTER       _FcntlOpcode = 28
+	_FCNTL_WIN32_GET_HANDLE      _FcntlOpcode = 29
+	_FCNTL_PDB                   _FcntlOpcode = 30
+	_FCNTL_BEGIN_ATOMIC_WRITE    _FcntlOpcode = 31
+	_FCNTL_COMMIT_ATOMIC_WRITE   _FcntlOpcode = 32
+	_FCNTL_ROLLBACK_ATOMIC_WRITE _FcntlOpcode = 33
+	_FCNTL_LOCK_TIMEOUT          _FcntlOpcode = 34
+	_FCNTL_DATA_VERSION          _FcntlOpcode = 35
+	_FCNTL_SIZE_LIMIT            _FcntlOpcode = 36
+	_FCNTL_CKPT_DONE             _FcntlOpcode = 37
+	_FCNTL_RESERVE_BYTES         _FcntlOpcode = 38
+	_FCNTL_CKPT_START            _FcntlOpcode = 39
+	_FCNTL_EXTERNAL_READER       _FcntlOpcode = 40
+	_FCNTL_CKSM_FILE             _FcntlOpcode = 41
+	_FCNTL_RESET_CACHE           _FcntlOpcode = 42
+)

sqlite3vfs/tests/mptest/mptest_test.go

@@ -16,11 +16,10 @@ import (
 	"sync/atomic"
 	"testing"
 
+	"github.com/ncruces/go-sqlite3/sqlite3vfs"
 	"github.com/tetratelabs/wazero"
 	"github.com/tetratelabs/wazero/api"
 	"github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1"
-
-	"github.com/ncruces/go-sqlite3/internal/vfs"
 )
 
 //go:embed testdata/mptest.wasm
@@ -41,7 +40,7 @@ func init() {
 	rt = wazero.NewRuntime(ctx)
 	wasi_snapshot_preview1.MustInstantiate(ctx, rt)
 
-	env := vfs.Export(rt.NewHostModuleBuilder("env"))
+	env := sqlite3vfs.ExportHostFunctions(rt.NewHostModuleBuilder("env"))
 	env.NewFunctionBuilder().WithFunc(system).Export("system")
 	_, err := env.Instantiate(ctx)
 	if err != nil {
@@ -81,23 +80,24 @@ func system(ctx context.Context, mod api.Module, ptr uint32) uint32 {
 
 	cfg := config(ctx).WithArgs(args...)
 	go func() {
-		ctx, vfs := vfs.Context(ctx)
-		rt.InstantiateModule(ctx, module, cfg)
+		ctx, vfs := sqlite3vfs.NewContext(ctx)
+		mod, _ := rt.InstantiateModule(ctx, module, cfg)
+		mod.Close(ctx)
 		vfs.Close()
 	}()
 	return 0
 }
 
 func Test_config01(t *testing.T) {
-	ctx, vfs := vfs.Context(newContext(t))
+	ctx, vfs := sqlite3vfs.NewContext(newContext(t))
 	name := filepath.Join(t.TempDir(), "test.db")
 	cfg := config(ctx).WithArgs("mptest", name, "config01.test")
 	mod, err := rt.InstantiateModule(ctx, module, cfg)
 	if err != nil {
 		t.Error(err)
 	}
-	vfs.Close()
 	mod.Close(ctx)
+	vfs.Close()
 }
 
 func Test_config02(t *testing.T) {
@@ -108,15 +108,15 @@ func Test_config02(t *testing.T) {
 		t.Skip("skipping in CI")
 	}
 
-	ctx, vfs := vfs.Context(newContext(t))
+	ctx, vfs := sqlite3vfs.NewContext(newContext(t))
 	name := filepath.Join(t.TempDir(), "test.db")
 	cfg := config(ctx).WithArgs("mptest", name, "config02.test")
 	mod, err := rt.InstantiateModule(ctx, module, cfg)
 	if err != nil {
 		t.Error(err)
 	}
-	vfs.Close()
 	mod.Close(ctx)
+	vfs.Close()
 }
 
 func Test_crash01(t *testing.T) {
@@ -124,15 +124,15 @@ func Test_crash01(t *testing.T) {
 		t.Skip("skipping in short mode")
 	}
 
-	ctx, vfs := vfs.Context(newContext(t))
+	ctx, vfs := sqlite3vfs.NewContext(newContext(t))
 	name := filepath.Join(t.TempDir(), "test.db")
 	cfg := config(ctx).WithArgs("mptest", name, "crash01.test")
 	mod, err := rt.InstantiateModule(ctx, module, cfg)
 	if err != nil {
 		t.Error(err)
 	}
-	vfs.Close()
 	mod.Close(ctx)
+	vfs.Close()
 }
 
 func Test_multiwrite01(t *testing.T) {
@@ -140,15 +140,15 @@ func Test_multiwrite01(t *testing.T) {
 		t.Skip("skipping in short mode")
 	}
 
-	ctx, vfs := vfs.Context(newContext(t))
+	ctx, vfs := sqlite3vfs.NewContext(newContext(t))
 	name := filepath.Join(t.TempDir(), "test.db")
 	cfg := config(ctx).WithArgs("mptest", name, "multiwrite01.test")
 	mod, err := rt.InstantiateModule(ctx, module, cfg)
 	if err != nil {
 		t.Error(err)
 	}
-	vfs.Close()
 	mod.Close(ctx)
+	vfs.Close()
 }
 
 func newContext(t *testing.T) context.Context {

sqlite3vfs/tests/mptest/testdata/build.sh

@@ -3,7 +3,7 @@ set -euo pipefail
 
 cd -P -- "$(dirname -- "$0")"
 
-ROOT=../../../../../
+ROOT=../../../../
 BINARYEN="$ROOT/tools/binaryen-version_112/bin"
 WASI_SDK="$ROOT/tools/wasi-sdk-20.0/bin"
 
@@ -15,7 +15,6 @@ WASI_SDK="$ROOT/tools/wasi-sdk-20.0/bin"
 	-mnontrapping-fptoint -msign-ext \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
-	-D_HAVE_SQLITE_CONFIG_H \
 	-DSQLITE_DEFAULT_SYNCHRONOUS=0 \
 	-DSQLITE_DEFAULT_LOCKING_MODE=0 \
 	-DHAVE_USLEEP -DSQLITE_NO_SYNC \

sqlite3vfs/tests/mptest/testdata/main.c

@@ -0,0 +1,18 @@
+#include <stdbool.h>
+#include <stddef.h>
+
+// Configuration
+#include "sqlite_cfg.h"
+// Amalgamation
+#include "sqlite3.c"
+// VFS
+#include "vfs.c"
+
+__attribute__((constructor)) void init() { sqlite3_initialize(); }
+
+static int dont_unlink(const char *pathname) { return 0; }
+#define sqlite3_enable_load_extension(...)
+#define sqlite3_trace(...)
+#define unlink dont_unlink
+#undef UNUSED_PARAMETER
+#include "mptest.c"

sqlite3vfs/tests/mptest/testdata/mptest.wasm

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

sqlite3vfs/tests/speedtest1/speedtest1_test.go

@@ -17,7 +17,7 @@ import (
 	"github.com/tetratelabs/wazero"
 	"github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1"
 
-	"github.com/ncruces/go-sqlite3/internal/vfs"
+	"github.com/ncruces/go-sqlite3/sqlite3vfs"
 )
 
 //go:embed testdata/speedtest1.wasm
@@ -35,7 +35,7 @@ func init() {
 
 	rt = wazero.NewRuntime(ctx)
 	wasi_snapshot_preview1.MustInstantiate(ctx, rt)
-	env := vfs.Export(rt.NewHostModuleBuilder("env"))
+	env := sqlite3vfs.ExportHostFunctions(rt.NewHostModuleBuilder("env"))
 	_, err := env.Instantiate(ctx)
 	if err != nil {
 		panic(err)
@@ -67,7 +67,7 @@ func TestMain(m *testing.M) {
 
 func Benchmark_speedtest1(b *testing.B) {
 	output.Reset()
-	ctx, vfs := vfs.Context(context.Background())
+	ctx, vfs := sqlite3vfs.NewContext(context.Background())
 	name := filepath.Join(b.TempDir(), "test.db")
 	args := append(options, "--size", strconv.Itoa(b.N), name)
 	cfg := wazero.NewModuleConfig().
@@ -80,6 +80,6 @@ func Benchmark_speedtest1(b *testing.B) {
 	if err != nil {
 		b.Error(err)
 	}
-	vfs.Close()
 	mod.Close(ctx)
+	vfs.Close()
 }

sqlite3vfs/tests/speedtest1/testdata/build.sh

@@ -3,7 +3,7 @@ set -euo pipefail
 
 cd -P -- "$(dirname -- "$0")"
 
-ROOT=../../../../../
+ROOT=../../../../
 BINARYEN="$ROOT/tools/binaryen-version_112/bin"
 WASI_SDK="$ROOT/tools/wasi-sdk-20.0/bin"
 
@@ -14,8 +14,7 @@ WASI_SDK="$ROOT/tools/wasi-sdk-20.0/bin"
 	-mbulk-memory -mreference-types \
 	-mnontrapping-fptoint -msign-ext \
 	-Wl,--stack-first \
-	-Wl,--import-undefined \
-	-D_HAVE_SQLITE_CONFIG_H
+	-Wl,--import-undefined
 
 "$BINARYEN/wasm-opt" -g -O2 speedtest1.wasm -o speedtest1.tmp \
 	--enable-multivalue --enable-mutable-globals \

sqlite3vfs/tests/speedtest1/testdata/main.c

@@ -0,0 +1,12 @@
+#include <stdbool.h>
+#include <stddef.h>
+
+// Configuration
+#include "sqlite_cfg.h"
+// Amalgamation
+#include "sqlite3.c"
+// VFS
+#include "vfs.c"
+
+#define randomFunc(args...) randomFunc2(args)
+#include "speedtest1.c"

sqlite3vfs/tests/speedtest1/testdata/speedtest1.wasm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2638f5458f93b60f97006456f60e3e294cffb9ac22b20dba748fbd12e34f056d
+size 1515841

sqlite3vfs/vfs.go

@@ -0,0 +1,366 @@
+package sqlite3vfs
+
+import (
+	"context"
+	"crypto/rand"
+	"io"
+	"reflect"
+	"time"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/ncruces/julianday"
+	"github.com/tetratelabs/wazero"
+	"github.com/tetratelabs/wazero/api"
+)
+
+// ExportHostFunctions registers the required VFS host functions
+// with the provided env module.
+//
+// Users of the [github.com/ncruces/go-sqlite3] package need not call this directly.
+func ExportHostFunctions(env wazero.HostModuleBuilder) wazero.HostModuleBuilder {
+	util.ExportFuncII(env, "go_vfs_find", vfsFind)
+	util.ExportFuncIIJ(env, "go_localtime", vfsLocaltime)
+	util.ExportFuncIIII(env, "go_randomness", vfsRandomness)
+	util.ExportFuncIII(env, "go_sleep", vfsSleep)
+	util.ExportFuncIII(env, "go_current_time", vfsCurrentTime)
+	util.ExportFuncIII(env, "go_current_time_64", vfsCurrentTime64)
+	util.ExportFuncIIIII(env, "go_full_pathname", vfsFullPathname)
+	util.ExportFuncIIII(env, "go_delete", vfsDelete)
+	util.ExportFuncIIIII(env, "go_access", vfsAccess)
+	util.ExportFuncIIIIII(env, "go_open", vfsOpen)
+	util.ExportFuncII(env, "go_close", vfsClose)
+	util.ExportFuncIIIIJ(env, "go_read", vfsRead)
+	util.ExportFuncIIIIJ(env, "go_write", vfsWrite)
+	util.ExportFuncIIJ(env, "go_truncate", vfsTruncate)
+	util.ExportFuncIII(env, "go_sync", vfsSync)
+	util.ExportFuncIII(env, "go_file_size", vfsFileSize)
+	util.ExportFuncIIII(env, "go_file_control", vfsFileControl)
+	util.ExportFuncII(env, "go_sector_size", vfsSectorSize)
+	util.ExportFuncII(env, "go_device_characteristics", vfsDeviceCharacteristics)
+	util.ExportFuncIII(env, "go_lock", vfsLock)
+	util.ExportFuncIII(env, "go_unlock", vfsUnlock)
+	util.ExportFuncIII(env, "go_check_reserved_lock", vfsCheckReservedLock)
+	return env
+}
+
+type vfsKey struct{}
+type vfsState struct {
+	files []File
+}
+
+// NewContext creates a new context to hold [api.Module] specific VFS data.
+//
+// This context should be passed to any [api.Function] calls that might
+// generate VFS host callbacks.
+//
+// The returned [io.Closer] should be closed after the [api.Module] is closed,
+// to release any associated resources.
+//
+// Users of the [github.com/ncruces/go-sqlite3] package need not call this directly.
+func NewContext(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 vfsFind(ctx context.Context, mod api.Module, zVfsName uint32) uint32 {
+	name := util.ReadString(mod, zVfsName, _MAX_STRING)
+	if Find(name) != nil {
+		return 1
+	}
+	return 0
+}
+
+func vfsLocaltime(ctx context.Context, mod api.Module, pTm uint32, t int64) _ErrorCode {
+	tm := time.Unix(t, 0)
+	var isdst int
+	if tm.IsDST() {
+		isdst = 1
+	}
+
+	const size = 32 / 8
+	// https://pubs.opengroup.org/onlinepubs/7908799/xsh/time.h.html
+	util.WriteUint32(mod, pTm+0*size, uint32(tm.Second()))
+	util.WriteUint32(mod, pTm+1*size, uint32(tm.Minute()))
+	util.WriteUint32(mod, pTm+2*size, uint32(tm.Hour()))
+	util.WriteUint32(mod, pTm+3*size, uint32(tm.Day()))
+	util.WriteUint32(mod, pTm+4*size, uint32(tm.Month()-time.January))
+	util.WriteUint32(mod, pTm+5*size, uint32(tm.Year()-1900))
+	util.WriteUint32(mod, pTm+6*size, uint32(tm.Weekday()-time.Sunday))
+	util.WriteUint32(mod, pTm+7*size, uint32(tm.YearDay()-1))
+	util.WriteUint32(mod, pTm+8*size, uint32(isdst))
+	return _OK
+}
+
+func vfsRandomness(ctx context.Context, mod api.Module, pVfs, nByte, zByte uint32) uint32 {
+	mem := util.View(mod, zByte, uint64(nByte))
+	n, _ := rand.Reader.Read(mem)
+	return uint32(n)
+}
+
+func vfsSleep(ctx context.Context, mod api.Module, pVfs, nMicro uint32) _ErrorCode {
+	time.Sleep(time.Duration(nMicro) * time.Microsecond)
+	return _OK
+}
+
+func vfsCurrentTime(ctx context.Context, mod api.Module, pVfs, prNow uint32) _ErrorCode {
+	day := julianday.Float(time.Now())
+	util.WriteFloat64(mod, prNow, day)
+	return _OK
+}
+
+func vfsCurrentTime64(ctx context.Context, mod api.Module, pVfs, piNow uint32) _ErrorCode {
+	day, nsec := julianday.Date(time.Now())
+	msec := day*86_400_000 + nsec/1_000_000
+	util.WriteUint64(mod, piNow, uint64(msec))
+	return _OK
+}
+
+func vfsFullPathname(ctx context.Context, mod api.Module, pVfs, zRelative, nFull, zFull uint32) _ErrorCode {
+	vfs := vfsGet(mod, pVfs)
+	path := util.ReadString(mod, zRelative, _MAX_PATHNAME)
+
+	path, err := vfs.FullPathname(path)
+
+	size := uint64(len(path) + 1)
+	if size > uint64(nFull) {
+		return _CANTOPEN_FULLPATH
+	}
+	mem := util.View(mod, zFull, size)
+	mem[len(path)] = 0
+	copy(mem, path)
+
+	return vfsErrorCode(err, _CANTOPEN_FULLPATH)
+}
+
+func vfsDelete(ctx context.Context, mod api.Module, pVfs, zPath, syncDir uint32) _ErrorCode {
+	vfs := vfsGet(mod, pVfs)
+	path := util.ReadString(mod, zPath, _MAX_PATHNAME)
+
+	err := vfs.Delete(path, syncDir != 0)
+	return vfsErrorCode(err, _IOERR_DELETE)
+}
+
+func vfsAccess(ctx context.Context, mod api.Module, pVfs, zPath uint32, flags AccessFlag, pResOut uint32) _ErrorCode {
+	vfs := vfsGet(mod, pVfs)
+	path := util.ReadString(mod, zPath, _MAX_PATHNAME)
+
+	ok, err := vfs.Access(path, flags)
+	var res uint32
+	if ok {
+		res = 1
+	}
+
+	util.WriteUint32(mod, pResOut, res)
+	return vfsErrorCode(err, _IOERR_ACCESS)
+}
+
+func vfsOpen(ctx context.Context, mod api.Module, pVfs, zPath, pFile uint32, flags OpenFlag, pOutFlags uint32) _ErrorCode {
+	vfs := vfsGet(mod, pVfs)
+
+	var path string
+	if zPath != 0 {
+		path = util.ReadString(mod, zPath, _MAX_PATHNAME)
+	}
+
+	file, flags, err := vfs.Open(path, flags)
+	if err != nil {
+		return vfsErrorCode(err, _CANTOPEN)
+	}
+
+	vfsFileRegister(ctx, mod, pFile, file)
+	if pOutFlags != 0 {
+		util.WriteUint32(mod, pOutFlags, uint32(flags))
+	}
+	return _OK
+}
+
+func vfsClose(ctx context.Context, mod api.Module, pFile uint32) _ErrorCode {
+	err := vfsFileClose(ctx, mod, pFile)
+	if err != nil {
+		return _IOERR_CLOSE
+	}
+	return _OK
+}
+
+func vfsRead(ctx context.Context, mod api.Module, pFile, zBuf, iAmt uint32, iOfst int64) _ErrorCode {
+	file := vfsFileGet(ctx, mod, pFile)
+	buf := util.View(mod, zBuf, uint64(iAmt))
+
+	n, err := file.ReadAt(buf, iOfst)
+	if n == int(iAmt) {
+		return _OK
+	}
+	if n == 0 && err != io.EOF {
+		return _IOERR_READ
+	}
+	for i := range buf[n:] {
+		buf[n+i] = 0
+	}
+	return _IOERR_SHORT_READ
+}
+
+func vfsWrite(ctx context.Context, mod api.Module, pFile, zBuf, iAmt uint32, iOfst int64) _ErrorCode {
+	file := vfsFileGet(ctx, mod, pFile)
+	buf := util.View(mod, zBuf, uint64(iAmt))
+
+	_, err := file.WriteAt(buf, iOfst)
+	if err != nil {
+		return _IOERR_WRITE
+	}
+	return _OK
+}
+
+func vfsTruncate(ctx context.Context, mod api.Module, pFile uint32, nByte int64) _ErrorCode {
+	file := vfsFileGet(ctx, mod, pFile)
+	err := file.Truncate(nByte)
+	return vfsErrorCode(err, _IOERR_TRUNCATE)
+}
+
+func vfsSync(ctx context.Context, mod api.Module, pFile uint32, flags SyncFlag) _ErrorCode {
+	file := vfsFileGet(ctx, mod, pFile)
+	err := file.Sync(flags)
+	return vfsErrorCode(err, _IOERR_FSYNC)
+}
+
+func vfsFileSize(ctx context.Context, mod api.Module, pFile, pSize uint32) _ErrorCode {
+	file := vfsFileGet(ctx, mod, pFile)
+	size, err := file.FileSize()
+	util.WriteUint64(mod, pSize, uint64(size))
+	return vfsErrorCode(err, _IOERR_SEEK)
+}
+
+func vfsLock(ctx context.Context, mod api.Module, pFile uint32, eLock LockLevel) _ErrorCode {
+	file := vfsFileGet(ctx, mod, pFile)
+	err := file.Lock(eLock)
+	return vfsErrorCode(err, _IOERR_LOCK)
+}
+
+func vfsUnlock(ctx context.Context, mod api.Module, pFile uint32, eLock LockLevel) _ErrorCode {
+	file := vfsFileGet(ctx, mod, pFile)
+	err := file.Unlock(eLock)
+	return vfsErrorCode(err, _IOERR_UNLOCK)
+}
+
+func vfsCheckReservedLock(ctx context.Context, mod api.Module, pFile, pResOut uint32) _ErrorCode {
+	file := vfsFileGet(ctx, mod, pFile)
+	locked, err := file.CheckReservedLock()
+
+	var res uint32
+	if locked {
+		res = 1
+	}
+
+	util.WriteUint32(mod, pResOut, res)
+	return vfsErrorCode(err, _IOERR_CHECKRESERVEDLOCK)
+}
+
+func vfsFileControl(ctx context.Context, mod api.Module, pFile uint32, op _FcntlOpcode, pArg uint32) _ErrorCode {
+	file := vfsFileGet(ctx, mod, pFile)
+
+	switch op {
+	case _FCNTL_LOCKSTATE:
+		if file, ok := file.(FileLockState); ok {
+			util.WriteUint32(mod, pArg, uint32(file.LockState()))
+			return _OK
+		}
+
+	case _FCNTL_LOCK_TIMEOUT:
+		if file, ok := file.(*vfsFile); ok {
+			millis := file.lockTimeout.Milliseconds()
+			file.lockTimeout = time.Duration(util.ReadUint32(mod, pArg)) * time.Millisecond
+			util.WriteUint32(mod, pArg, uint32(millis))
+			return _OK
+		}
+
+	case _FCNTL_POWERSAFE_OVERWRITE:
+		if file, ok := file.(FilePowersafeOverwrite); ok {
+			switch util.ReadUint32(mod, pArg) {
+			case 0:
+				file.SetPowersafeOverwrite(false)
+			case 1:
+				file.SetPowersafeOverwrite(true)
+			default:
+				if file.PowersafeOverwrite() {
+					util.WriteUint32(mod, pArg, 1)
+				} else {
+					util.WriteUint32(mod, pArg, 0)
+				}
+			}
+			return _OK
+		}
+
+	case _FCNTL_SIZE_HINT:
+		if file, ok := file.(FileSizeHint); ok {
+			size := util.ReadUint64(mod, pArg)
+			err := file.SizeHint(int64(size))
+			return vfsErrorCode(err, _IOERR_TRUNCATE)
+		}
+
+	case _FCNTL_HAS_MOVED:
+		if file, ok := file.(FileHasMoved); ok {
+			moved, err := file.HasMoved()
+
+			var res uint32
+			if moved {
+				res = 1
+			}
+
+			util.WriteUint32(mod, pArg, res)
+			return vfsErrorCode(err, _IOERR_FSTAT)
+		}
+	}
+
+	// Consider also implementing these opcodes (in use by SQLite):
+	//  _FCNTL_BUSYHANDLER
+	//  _FCNTL_COMMIT_PHASETWO
+	//  _FCNTL_PDB
+	//  _FCNTL_PRAGMA
+	//  _FCNTL_SYNC
+	return _NOTFOUND
+}
+
+func vfsSectorSize(ctx context.Context, mod api.Module, pFile uint32) uint32 {
+	file := vfsFileGet(ctx, mod, pFile)
+	return uint32(file.SectorSize())
+}
+
+func vfsDeviceCharacteristics(ctx context.Context, mod api.Module, pFile uint32) DeviceCharacteristic {
+	file := vfsFileGet(ctx, mod, pFile)
+	return file.DeviceCharacteristics()
+}
+
+func vfsGet(mod api.Module, pVfs uint32) VFS {
+	if pVfs == 0 {
+		return vfsOS{}
+	}
+	const zNameOffset = 16
+	name := util.ReadString(mod, util.ReadUint32(mod, pVfs+zNameOffset), _MAX_STRING)
+	if name == "os" {
+		return vfsOS{}
+	}
+	if vfs := Find(name); vfs != nil {
+		return vfs
+	}
+	panic(util.NoVFSErr + util.ErrorString(name))
+}
+
+func vfsErrorCode(err error, def _ErrorCode) _ErrorCode {
+	if err == nil {
+		return _OK
+	}
+	switch v := reflect.ValueOf(err); v.Kind() {
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32:
+		return _ErrorCode(v.Uint())
+	}
+	return def
+}

sqlite3vfs/vfs_api.go

@@ -0,0 +1,109 @@
+// Package sqlite3vfs wraps the C SQLite VFS API.
+package sqlite3vfs
+
+import "sync"
+
+// A VFS defines the interface between the SQLite core and the underlying operating system.
+//
+// Use sqlite3.ErrorCode or sqlite3.ExtendedErrorCode to return specific error codes.
+//
+// https://www.sqlite.org/c3ref/vfs.html
+type VFS interface {
+	Open(name string, flags OpenFlag) (File, OpenFlag, error)
+	Delete(name string, syncDir bool) error
+	Access(name string, flags AccessFlag) (bool, error)
+	FullPathname(name string) (string, error)
+}
+
+// A File represents an open file in the OS interface layer.
+//
+// Use sqlite3.ErrorCode or sqlite3.ExtendedErrorCode to return specific error codes.
+// In particular, sqlite3.BUSY is necessary to correctly implement lock methods.
+//
+// https://www.sqlite.org/c3ref/io_methods.html
+type File interface {
+	Close() error
+	ReadAt(p []byte, off int64) (n int, err error)
+	WriteAt(p []byte, off int64) (n int, err error)
+	Truncate(size int64) error
+	Sync(flags SyncFlag) error
+	FileSize() (int64, error)
+	Lock(lock LockLevel) error
+	Unlock(lock LockLevel) error
+	CheckReservedLock() (bool, error)
+	SectorSize() int
+	DeviceCharacteristics() DeviceCharacteristic
+}
+
+// FileLockState extends [File] to implement the
+// SQLITE_FCNTL_LOCKSTATE file control opcode.
+//
+// https://www.sqlite.org/c3ref/c_fcntl_begin_atomic_write.html
+type FileLockState interface {
+	File
+	LockState() LockLevel
+}
+
+// FileLockState extends [File] to implement the
+// SQLITE_FCNTL_SIZE_HINT file control opcode.
+//
+// https://www.sqlite.org/c3ref/c_fcntl_begin_atomic_write.html
+type FileSizeHint interface {
+	File
+	SizeHint(size int64) error
+}
+
+// FileLockState extends [File] to implement the
+// SQLITE_FCNTL_HAS_MOVED file control opcode.
+//
+// https://www.sqlite.org/c3ref/c_fcntl_begin_atomic_write.html
+type FileHasMoved interface {
+	File
+	HasMoved() (bool, error)
+}
+
+// FileLockState extends [File] to implement the
+// SQLITE_FCNTL_POWERSAFE_OVERWRITE file control opcode.
+//
+// https://www.sqlite.org/c3ref/c_fcntl_begin_atomic_write.html
+type FilePowersafeOverwrite interface {
+	File
+	PowersafeOverwrite() bool
+	SetPowersafeOverwrite(bool)
+}
+
+var (
+	vfsRegistry    map[string]VFS
+	vfsRegistryMtx sync.Mutex
+)
+
+// Find returns a VFS given its name.
+// If there is no match, nil is returned.
+//
+// https://www.sqlite.org/c3ref/vfs_find.html
+func Find(name string) VFS {
+	vfsRegistryMtx.Lock()
+	defer vfsRegistryMtx.Unlock()
+	return vfsRegistry[name]
+}
+
+// Register registers a VFS.
+//
+// https://www.sqlite.org/c3ref/vfs_find.html
+func Register(name string, vfs VFS) {
+	vfsRegistryMtx.Lock()
+	defer vfsRegistryMtx.Unlock()
+	if vfsRegistry == nil {
+		vfsRegistry = map[string]VFS{}
+	}
+	vfsRegistry[name] = vfs
+}
+
+// Unregister unregisters a VFS.
+//
+// https://www.sqlite.org/c3ref/vfs_find.html
+func Unregister(name string) {
+	vfsRegistryMtx.Lock()
+	defer vfsRegistryMtx.Unlock()
+	delete(vfsRegistry, name)
+}

sqlite3vfs/vfs_api_test.go

@@ -0,0 +1,48 @@
+package sqlite3vfs_test
+
+import (
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+	_ "github.com/ncruces/go-sqlite3/embed"
+	"github.com/ncruces/go-sqlite3/sqlite3vfs"
+)
+
+type testVFS struct {
+	*testing.T
+}
+
+func (t testVFS) Open(name string, flags sqlite3vfs.OpenFlag) (sqlite3vfs.File, sqlite3vfs.OpenFlag, error) {
+	t.Log("Open", name, flags)
+	t.SkipNow()
+	return nil, flags, nil
+}
+
+func (t testVFS) Delete(name string, syncDir bool) error {
+	t.Log("Delete", name, syncDir)
+	return nil
+}
+
+func (t testVFS) Access(name string, flags sqlite3vfs.AccessFlag) (bool, error) {
+	t.Log("Access", name, flags)
+	return true, nil
+}
+
+func (t testVFS) FullPathname(name string) (string, error) {
+	t.Log("FullPathname", name)
+	return name, nil
+}
+
+func TestRegister(t *testing.T) {
+	vfs := testVFS{t}
+	sqlite3vfs.Register("foo", vfs)
+	defer sqlite3vfs.Unregister("foo")
+
+	conn, err := sqlite3.Open("file:file.db?vfs=foo")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer conn.Close()
+
+	t.Error("want skip")
+}

sqlite3vfs/vfs_file.go

@@ -0,0 +1,223 @@
+package sqlite3vfs
+
+import (
+	"context"
+	"errors"
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"runtime"
+	"time"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/tetratelabs/wazero/api"
+)
+
+type vfsOS struct{}
+
+func (vfsOS) FullPathname(path string) (string, error) {
+	path, err := filepath.Abs(path)
+	if err != nil {
+		return "", err
+	}
+	fi, err := os.Lstat(path)
+	if err != nil {
+		if errors.Is(err, fs.ErrNotExist) {
+			return path, nil
+		}
+		return "", err
+	}
+	if fi.Mode()&fs.ModeSymlink != 0 {
+		err = _OK_SYMLINK
+	}
+	return path, err
+}
+
+func (vfsOS) Delete(path string, syncDir bool) error {
+	err := os.Remove(path)
+	if errors.Is(err, fs.ErrNotExist) {
+		return _IOERR_DELETE_NOENT
+	}
+	if err != nil {
+		return err
+	}
+	if runtime.GOOS != "windows" && syncDir {
+		f, err := os.Open(filepath.Dir(path))
+		if err != nil {
+			return _OK
+		}
+		defer f.Close()
+		err = osSync(f, false, false)
+		if err != nil {
+			return _IOERR_DIR_FSYNC
+		}
+	}
+	return nil
+}
+
+func (vfsOS) Access(name string, flags AccessFlag) (bool, error) {
+	err := osAccess(name, flags)
+	if flags == ACCESS_EXISTS {
+		if errors.Is(err, fs.ErrNotExist) {
+			return false, nil
+		}
+	} else {
+		if errors.Is(err, fs.ErrPermission) {
+			return false, nil
+		}
+	}
+	return err == nil, err
+}
+
+func (vfsOS) Open(name string, flags OpenFlag) (File, OpenFlag, error) {
+	var oflags int
+	if flags&OPEN_EXCLUSIVE != 0 {
+		oflags |= os.O_EXCL
+	}
+	if flags&OPEN_CREATE != 0 {
+		oflags |= os.O_CREATE
+	}
+	if flags&OPEN_READONLY != 0 {
+		oflags |= os.O_RDONLY
+	}
+	if flags&OPEN_READWRITE != 0 {
+		oflags |= os.O_RDWR
+	}
+
+	var err error
+	var f *os.File
+	if name == "" {
+		f, err = os.CreateTemp("", "*.db")
+	} else {
+		f, err = osOpenFile(name, oflags, 0666)
+	}
+	if err != nil {
+		return nil, flags, err
+	}
+
+	if flags&OPEN_DELETEONCLOSE != 0 {
+		os.Remove(f.Name())
+	}
+
+	file := vfsFile{
+		File:     f,
+		psow:     true,
+		readOnly: flags&OPEN_READONLY != 0,
+		syncDir: runtime.GOOS != "windows" &&
+			flags&(OPEN_CREATE) != 0 &&
+			flags&(OPEN_MAIN_JOURNAL|OPEN_SUPER_JOURNAL|OPEN_WAL) != 0,
+	}
+	return &file, flags, nil
+}
+
+type vfsFile struct {
+	*os.File
+	lockTimeout time.Duration
+	lock        LockLevel
+	psow        bool
+	syncDir     bool
+	readOnly    bool
+}
+
+var (
+	// Ensure these interfaces are implemented:
+	_ FileLockState          = &vfsFile{}
+	_ FileHasMoved           = &vfsFile{}
+	_ FileSizeHint           = &vfsFile{}
+	_ FilePowersafeOverwrite = &vfsFile{}
+)
+
+func vfsFileNew(vfs *vfsState, file File) uint32 {
+	// Find an empty slot.
+	for id, f := range vfs.files {
+		if f == 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 vfsFileRegister(ctx context.Context, mod api.Module, pFile uint32, file File) {
+	const fileHandleOffset = 4
+	id := vfsFileNew(ctx.Value(vfsKey{}).(*vfsState), file)
+	util.WriteUint32(mod, pFile+fileHandleOffset, id)
+}
+
+func vfsFileGet(ctx context.Context, mod api.Module, pFile uint32) File {
+	const fileHandleOffset = 4
+	vfs := ctx.Value(vfsKey{}).(*vfsState)
+	id := util.ReadUint32(mod, pFile+fileHandleOffset)
+	return vfs.files[id]
+}
+
+func vfsFileClose(ctx context.Context, mod api.Module, pFile uint32) error {
+	const fileHandleOffset = 4
+	vfs := ctx.Value(vfsKey{}).(*vfsState)
+	id := util.ReadUint32(mod, pFile+fileHandleOffset)
+	file := vfs.files[id]
+	vfs.files[id] = nil
+	return file.Close()
+}
+
+func (f *vfsFile) Sync(flags SyncFlag) error {
+	dataonly := (flags & SYNC_DATAONLY) != 0
+	fullsync := (flags & 0x0f) == SYNC_FULL
+
+	err := osSync(f.File, fullsync, dataonly)
+	if err != nil {
+		return err
+	}
+	if runtime.GOOS != "windows" && f.syncDir {
+		f.syncDir = false
+		d, err := os.Open(filepath.Dir(f.File.Name()))
+		if err != nil {
+			return nil
+		}
+		defer d.Close()
+		err = osSync(d, false, false)
+		if err != nil {
+			return _IOERR_DIR_FSYNC
+		}
+	}
+	return nil
+}
+
+func (f *vfsFile) FileSize() (int64, error) {
+	return f.Seek(0, io.SeekEnd)
+}
+
+func (*vfsFile) SectorSize() int {
+	return _DEFAULT_SECTOR_SIZE
+}
+
+func (f *vfsFile) DeviceCharacteristics() DeviceCharacteristic {
+	if f.psow {
+		return IOCAP_POWERSAFE_OVERWRITE
+	}
+	return 0
+}
+
+func (f *vfsFile) SizeHint(size int64) error {
+	return osAllocate(f.File, size)
+}
+
+func (f *vfsFile) HasMoved() (bool, error) {
+	fi, err := f.Stat()
+	if err != nil {
+		return false, err
+	}
+	pi, err := os.Stat(f.Name())
+	if err != nil && !errors.Is(err, fs.ErrNotExist) {
+		return false, err
+	}
+	return !os.SameFile(fi, pi), nil
+}
+
+func (f *vfsFile) LockState() LockLevel            { return f.lock }
+func (f *vfsFile) PowersafeOverwrite() bool        { return f.psow }
+func (f *vfsFile) SetPowersafeOverwrite(psow bool) { f.psow = psow }

sqlite3vfs/vfs_lock.go

@@ -1,12 +1,10 @@
-package vfs
+package sqlite3vfs
 
 import (
-	"context"
 	"os"
 	"time"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
-	"github.com/tetratelabs/wazero/api"
 )
 
 const (
@@ -16,111 +14,107 @@ const (
 	_SHARED_SIZE   = 510
 )
 
-func vfsLock(ctx context.Context, mod api.Module, pFile uint32, eLock _LockLevel) _ErrorCode {
+func (file *vfsFile) Lock(eLock LockLevel) error {
 	// Argument check. SQLite never explicitly requests a pending lock.
-	if eLock != _LOCK_SHARED && eLock != _LOCK_RESERVED && eLock != _LOCK_EXCLUSIVE {
+	if eLock != LOCK_SHARED && eLock != LOCK_RESERVED && eLock != LOCK_EXCLUSIVE {
 		panic(util.AssertErr())
 	}
 
-	file := getVFSFile(ctx, mod, pFile)
-
 	switch {
-	case file.lock < _LOCK_NONE || file.lock > _LOCK_EXCLUSIVE:
+	case file.lock < LOCK_NONE || file.lock > LOCK_EXCLUSIVE:
 		// Connection state check.
 		panic(util.AssertErr())
-	case file.lock == _LOCK_NONE && eLock > _LOCK_SHARED:
+	case file.lock == LOCK_NONE && eLock > LOCK_SHARED:
 		// We never move from unlocked to anything higher than a shared lock.
 		panic(util.AssertErr())
-	case file.lock != _LOCK_SHARED && eLock == _LOCK_RESERVED:
+	case file.lock != LOCK_SHARED && eLock == LOCK_RESERVED:
 		// A shared lock is always held when a reserved lock is requested.
 		panic(util.AssertErr())
 	}
 
 	// If we already have an equal or more restrictive lock, do nothing.
 	if file.lock >= eLock {
-		return _OK
+		return nil
 	}
 
 	// Do not allow any kind of write-lock on a read-only database.
-	if file.readOnly && eLock >= _LOCK_RESERVED {
+	if file.readOnly && eLock >= LOCK_RESERVED {
 		return _IOERR_LOCK
 	}
 
 	switch eLock {
-	case _LOCK_SHARED:
+	case LOCK_SHARED:
 		// Must be unlocked to get SHARED.
-		if file.lock != _LOCK_NONE {
+		if file.lock != LOCK_NONE {
 			panic(util.AssertErr())
 		}
 		if rc := osGetSharedLock(file.File, file.lockTimeout); rc != _OK {
 			return rc
 		}
-		file.lock = _LOCK_SHARED
-		return _OK
+		file.lock = LOCK_SHARED
+		return nil
 
-	case _LOCK_RESERVED:
+	case LOCK_RESERVED:
 		// Must be SHARED to get RESERVED.
-		if file.lock != _LOCK_SHARED {
+		if file.lock != LOCK_SHARED {
 			panic(util.AssertErr())
 		}
 		if rc := osGetReservedLock(file.File, file.lockTimeout); rc != _OK {
 			return rc
 		}
-		file.lock = _LOCK_RESERVED
-		return _OK
+		file.lock = LOCK_RESERVED
+		return nil
 
-	case _LOCK_EXCLUSIVE:
+	case LOCK_EXCLUSIVE:
 		// Must be SHARED, RESERVED or PENDING to get EXCLUSIVE.
-		if file.lock <= _LOCK_NONE || file.lock >= _LOCK_EXCLUSIVE {
+		if file.lock <= LOCK_NONE || file.lock >= LOCK_EXCLUSIVE {
 			panic(util.AssertErr())
 		}
 		// A PENDING lock is needed before acquiring an EXCLUSIVE lock.
-		if file.lock < _LOCK_PENDING {
+		if file.lock < LOCK_PENDING {
 			if rc := osGetPendingLock(file.File); rc != _OK {
 				return rc
 			}
-			file.lock = _LOCK_PENDING
+			file.lock = LOCK_PENDING
 		}
 		if rc := osGetExclusiveLock(file.File, file.lockTimeout); rc != _OK {
 			return rc
 		}
-		file.lock = _LOCK_EXCLUSIVE
-		return _OK
+		file.lock = LOCK_EXCLUSIVE
+		return nil
 
 	default:
 		panic(util.AssertErr())
 	}
 }
 
-func vfsUnlock(ctx context.Context, mod api.Module, pFile uint32, eLock _LockLevel) _ErrorCode {
+func (file *vfsFile) Unlock(eLock LockLevel) error {
 	// Argument check.
-	if eLock != _LOCK_NONE && eLock != _LOCK_SHARED {
+	if eLock != LOCK_NONE && eLock != LOCK_SHARED {
 		panic(util.AssertErr())
 	}
 
-	file := getVFSFile(ctx, mod, pFile)
-
 	// Connection state check.
-	if file.lock < _LOCK_NONE || file.lock > _LOCK_EXCLUSIVE {
+	if file.lock < LOCK_NONE || file.lock > LOCK_EXCLUSIVE {
 		panic(util.AssertErr())
 	}
 
 	// If we don't have a more restrictive lock, do nothing.
 	if file.lock <= eLock {
-		return _OK
+		return nil
 	}
 
 	switch eLock {
-	case _LOCK_SHARED:
+	case LOCK_SHARED:
 		if rc := osDowngradeLock(file.File, file.lock); rc != _OK {
 			return rc
 		}
-		file.lock = _LOCK_SHARED
-		return _OK
+		file.lock = LOCK_SHARED
+		return nil
 
-	case _LOCK_NONE:
+	case LOCK_NONE:
 		rc := osReleaseLock(file.File, file.lock)
-		file.lock = _LOCK_NONE
+		file.lock = LOCK_NONE
 		return rc
 
 	default:
@@ -128,28 +122,16 @@ func vfsUnlock(ctx context.Context, mod api.Module, pFile uint32, eLock _LockLev
 	}
 }
 
-func vfsCheckReservedLock(ctx context.Context, mod api.Module, pFile, pResOut uint32) _ErrorCode {
-	file := getVFSFile(ctx, mod, pFile)
-
+func (file *vfsFile) CheckReservedLock() (bool, error) {
 	// Connection state check.
-	if file.lock < _LOCK_NONE || file.lock > _LOCK_EXCLUSIVE {
+	if file.lock < LOCK_NONE || file.lock > LOCK_EXCLUSIVE {
 		panic(util.AssertErr())
 	}
 
-	var locked bool
-	var rc _ErrorCode
-	if file.lock >= _LOCK_RESERVED {
-		locked = true
-	} else {
-		locked, rc = osCheckReservedLock(file.File)
+	if file.lock >= LOCK_RESERVED {
+		return true, nil
 	}
-
-	var res uint32
-	if locked {
-		res = 1
-	}
-	util.WriteUint32(mod, pResOut, res)
-	return rc
+	return osCheckReservedLock(file.File)
 }
 
 func osGetReservedLock(file *os.File, timeout time.Duration) _ErrorCode {

sqlite3vfs/vfs_lock_test.go

@@ -1,4 +1,4 @@
-package vfs
+package sqlite3vfs
 
 import (
 	"context"
@@ -40,11 +40,11 @@ func Test_vfsLock(t *testing.T) {
 		pOutput = 32
 	)
 	mod := util.NewMockModule(128)
-	ctx, vfs := Context(context.TODO())
+	ctx, vfs := NewContext(context.TODO())
 	defer vfs.Close()
 
-	openVFSFile(ctx, mod, pFile1, file1)
-	openVFSFile(ctx, mod, pFile2, file2)
+	vfsFileRegister(ctx, mod, pFile1, &vfsFile{File: file1})
+	vfsFileRegister(ctx, mod, pFile2, &vfsFile{File: file2})
 
 	rc := vfsCheckReservedLock(ctx, mod, pFile1, pOutput)
 	if rc != _OK {
@@ -60,8 +60,15 @@ func Test_vfsLock(t *testing.T) {
 	if got := util.ReadUint32(mod, pOutput); got != 0 {
 		t.Error("file was locked")
 	}
+	rc = vfsFileControl(ctx, mod, pFile2, _FCNTL_LOCKSTATE, pOutput)
+	if rc != _OK {
+		t.Fatal("returned", rc)
+	}
+	if got := util.ReadUint32(mod, pOutput); got != uint32(LOCK_NONE) {
+		t.Error("invalid lock state", got)
+	}
 
-	rc = vfsLock(ctx, mod, pFile2, _LOCK_SHARED)
+	rc = vfsLock(ctx, mod, pFile2, LOCK_SHARED)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -80,12 +87,19 @@ func Test_vfsLock(t *testing.T) {
 	if got := util.ReadUint32(mod, pOutput); got != 0 {
 		t.Error("file was locked")
 	}
-
-	rc = vfsLock(ctx, mod, pFile2, _LOCK_RESERVED)
+	rc = vfsFileControl(ctx, mod, pFile2, _FCNTL_LOCKSTATE, pOutput)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
-	rc = vfsLock(ctx, mod, pFile2, _LOCK_SHARED)
+	if got := util.ReadUint32(mod, pOutput); got != uint32(LOCK_SHARED) {
+		t.Error("invalid lock state", got)
+	}
+
+	rc = vfsLock(ctx, mod, pFile2, LOCK_RESERVED)
+	if rc != _OK {
+		t.Fatal("returned", rc)
+	}
+	rc = vfsLock(ctx, mod, pFile2, LOCK_SHARED)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -104,8 +118,15 @@ func Test_vfsLock(t *testing.T) {
 	if got := util.ReadUint32(mod, pOutput); got == 0 {
 		t.Error("file wasn't locked")
 	}
+	rc = vfsFileControl(ctx, mod, pFile2, _FCNTL_LOCKSTATE, pOutput)
+	if rc != _OK {
+		t.Fatal("returned", rc)
+	}
+	if got := util.ReadUint32(mod, pOutput); got != uint32(LOCK_RESERVED) {
+		t.Error("invalid lock state", got)
+	}
 
-	rc = vfsLock(ctx, mod, pFile2, _LOCK_EXCLUSIVE)
+	rc = vfsLock(ctx, mod, pFile2, LOCK_EXCLUSIVE)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -124,8 +145,15 @@ func Test_vfsLock(t *testing.T) {
 	if got := util.ReadUint32(mod, pOutput); got == 0 {
 		t.Error("file wasn't locked")
 	}
+	rc = vfsFileControl(ctx, mod, pFile2, _FCNTL_LOCKSTATE, pOutput)
+	if rc != _OK {
+		t.Fatal("returned", rc)
+	}
+	if got := util.ReadUint32(mod, pOutput); got != uint32(LOCK_EXCLUSIVE) {
+		t.Error("invalid lock state", got)
+	}
 
-	rc = vfsLock(ctx, mod, pFile1, _LOCK_SHARED)
+	rc = vfsLock(ctx, mod, pFile1, LOCK_SHARED)
 	if rc == _OK {
 		t.Fatal("returned", rc)
 	}
@@ -144,8 +172,15 @@ func Test_vfsLock(t *testing.T) {
 	if got := util.ReadUint32(mod, pOutput); got == 0 {
 		t.Error("file wasn't locked")
 	}
+	rc = vfsFileControl(ctx, mod, pFile1, _FCNTL_LOCKSTATE, pOutput)
+	if rc != _OK {
+		t.Fatal("returned", rc)
+	}
+	if got := util.ReadUint32(mod, pOutput); got != uint32(LOCK_NONE) {
+		t.Error("invalid lock state", got)
+	}
 
-	rc = vfsUnlock(ctx, mod, pFile2, _LOCK_SHARED)
+	rc = vfsUnlock(ctx, mod, pFile2, LOCK_SHARED)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -165,7 +200,19 @@ func Test_vfsLock(t *testing.T) {
 		t.Error("file was locked")
 	}
 
-	rc = vfsLock(ctx, mod, pFile1, _LOCK_SHARED)
+	rc = vfsLock(ctx, mod, pFile1, LOCK_SHARED)
+	if rc != _OK {
+		t.Fatal("returned", rc)
+	}
+	rc = vfsFileControl(ctx, mod, pFile1, _FCNTL_LOCKSTATE, pOutput)
+	if rc != _OK {
+		t.Fatal("returned", rc)
+	}
+	if got := util.ReadUint32(mod, pOutput); got != uint32(LOCK_SHARED) {
+		t.Error("invalid lock state", got)
+	}
+
+	rc = vfsFileControl(ctx, mod, pFile1, _FCNTL_LOCK_TIMEOUT, 1)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}

sqlite3vfs/vfs_os_bsd.go

@@ -1,6 +1,6 @@
 //go:build freebsd || openbsd || netbsd || dragonfly || (darwin && sqlite3_bsd)
 
-package vfs
+package sqlite3vfs
 
 import (
 	"os"

sqlite3vfs/vfs_os_darwin.go

@@ -1,6 +1,6 @@
 //go:build !sqlite3_bsd
 
-package vfs
+package sqlite3vfs
 
 import (
 	"io"
@@ -47,7 +47,7 @@ func osAllocate(file *os.File, size int64) error {
 		Length:  size,
 	}
 
-	// Try to get a continous chunk of disk space.
+	// Try to get a continuous chunk of disk space.
 	err = unix.FcntlFstore(file.Fd(), unix.F_PREALLOCATE, &store)
 	if err != nil {
 		// OK, perhaps we are too fragmented, allocate non-continuous.

sqlite3vfs/vfs_os_linux.go

@@ -1,4 +1,4 @@
-package vfs
+package sqlite3vfs
 
 import (
 	"os"

sqlite3vfs/vfs_os_ofd.go

@@ -1,6 +1,6 @@
 //go:build linux || illumos
 
-package vfs
+package sqlite3vfs
 
 import (
 	"os"

sqlite3vfs/vfs_os_other.go

@@ -1,6 +1,6 @@
 //go:build !linux && (!darwin || sqlite3_bsd)
 
-package vfs
+package sqlite3vfs
 
 import (
 	"io"

sqlite3vfs/vfs_os_unix.go

@@ -1,6 +1,6 @@
 //go:build unix
 
-package vfs
+package sqlite3vfs
 
 import (
 	"io/fs"
@@ -14,12 +14,12 @@ func osOpenFile(name string, flag int, perm fs.FileMode) (*os.File, error) {
 	return os.OpenFile(name, flag, perm)
 }
 
-func osAccess(path string, flags _AccessFlag) error {
+func osAccess(path string, flags AccessFlag) error {
 	var access uint32 // unix.F_OK
 	switch flags {
-	case _ACCESS_READWRITE:
+	case ACCESS_READWRITE:
 		access = unix.R_OK | unix.W_OK
-	case _ACCESS_READ:
+	case ACCESS_READ:
 		access = unix.R_OK
 	}
 	return unix.Access(path, access)
@@ -28,7 +28,7 @@ func osAccess(path string, flags _AccessFlag) error {
 func osGetSharedLock(file *os.File, timeout time.Duration) _ErrorCode {
 	// Test the PENDING lock before acquiring a new SHARED lock.
 	if pending, _ := osCheckLock(file, _PENDING_BYTE, 1); pending {
-		return _ErrorCode(_BUSY)
+		return _BUSY
 	}
 	// Acquire the SHARED lock.
 	return osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, timeout)
@@ -43,8 +43,8 @@ func osGetExclusiveLock(file *os.File, timeout time.Duration) _ErrorCode {
 	return osWriteLock(file, _SHARED_FIRST, _SHARED_SIZE, timeout)
 }
 
-func osDowngradeLock(file *os.File, state _LockLevel) _ErrorCode {
-	if state >= _LOCK_EXCLUSIVE {
+func osDowngradeLock(file *os.File, state LockLevel) _ErrorCode {
+	if state >= LOCK_EXCLUSIVE {
 		// Downgrade to a SHARED lock.
 		if rc := osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0); rc != _OK {
 			// In theory, the downgrade to a SHARED cannot fail because another
@@ -59,7 +59,7 @@ func osDowngradeLock(file *os.File, state _LockLevel) _ErrorCode {
 	return osUnlock(file, _PENDING_BYTE, 2)
 }
 
-func osReleaseLock(file *os.File, _ _LockLevel) _ErrorCode {
+func osReleaseLock(file *os.File, _ LockLevel) _ErrorCode {
 	// Release all locks.
 	return osUnlock(file, 0, 0)
 }
@@ -78,9 +78,9 @@ func osLockErrorCode(err error, def _ErrorCode) _ErrorCode {
 			unix.ENOLCK,
 			unix.EDEADLK,
 			unix.ETIMEDOUT:
-			return _ErrorCode(_BUSY)
+			return _BUSY
 		case unix.EPERM:
-			return _ErrorCode(_PERM)
+			return _PERM
 		}
 	}
 	return def

sqlite3vfs/vfs_os_windows.go

@@ -1,4 +1,4 @@
-package vfs
+package sqlite3vfs
 
 import (
 	"io/fs"
@@ -25,17 +25,17 @@ func osOpenFile(name string, flag int, perm fs.FileMode) (*os.File, error) {
 	return os.NewFile(uintptr(r), name), nil
 }
 
-func osAccess(path string, flags _AccessFlag) error {
+func osAccess(path string, flags AccessFlag) error {
 	fi, err := os.Stat(path)
 	if err != nil {
 		return err
 	}
-	if flags == _ACCESS_EXISTS {
+	if flags == ACCESS_EXISTS {
 		return nil
 	}
 
 	var want fs.FileMode = windows.S_IRUSR
-	if flags == _ACCESS_READWRITE {
+	if flags == ACCESS_READWRITE {
 		want |= windows.S_IWUSR
 	}
 	if fi.IsDir() {
@@ -79,8 +79,8 @@ func osGetExclusiveLock(file *os.File, timeout time.Duration) _ErrorCode {
 	return rc
 }
 
-func osDowngradeLock(file *os.File, state _LockLevel) _ErrorCode {
-	if state >= _LOCK_EXCLUSIVE {
+func osDowngradeLock(file *os.File, state LockLevel) _ErrorCode {
+	if state >= LOCK_EXCLUSIVE {
 		// Release the SHARED lock.
 		osUnlock(file, _SHARED_FIRST, _SHARED_SIZE)
 
@@ -93,24 +93,24 @@ func osDowngradeLock(file *os.File, state _LockLevel) _ErrorCode {
 	}
 
 	// Release the PENDING and RESERVED locks.
-	if state >= _LOCK_RESERVED {
+	if state >= LOCK_RESERVED {
 		osUnlock(file, _RESERVED_BYTE, 1)
 	}
-	if state >= _LOCK_PENDING {
+	if state >= LOCK_PENDING {
 		osUnlock(file, _PENDING_BYTE, 1)
 	}
 	return _OK
 }
 
-func osReleaseLock(file *os.File, state _LockLevel) _ErrorCode {
+func osReleaseLock(file *os.File, state LockLevel) _ErrorCode {
 	// Release all locks.
-	if state >= _LOCK_RESERVED {
+	if state >= LOCK_RESERVED {
 		osUnlock(file, _RESERVED_BYTE, 1)
 	}
-	if state >= _LOCK_SHARED {
+	if state >= LOCK_SHARED {
 		osUnlock(file, _SHARED_FIRST, _SHARED_SIZE)
 	}
-	if state >= _LOCK_PENDING {
+	if state >= LOCK_PENDING {
 		osUnlock(file, _PENDING_BYTE, 1)
 	}
 	return _OK

sqlite3vfs/vfs_test.go

@@ -1,10 +1,11 @@
-package vfs
+package sqlite3vfs
 
 import (
 	"bytes"
 	"context"
 	"errors"
 	"io/fs"
+	"math"
 	"os"
 	"path/filepath"
 	"syscall"
@@ -181,7 +182,7 @@ func Test_vfsAccess(t *testing.T) {
 	util.WriteString(mod, 8, dir)
 	ctx := context.TODO()
 
-	rc := vfsAccess(ctx, mod, 0, 8, _ACCESS_EXISTS, 4)
+	rc := vfsAccess(ctx, mod, 0, 8, ACCESS_EXISTS, 4)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -189,7 +190,7 @@ func Test_vfsAccess(t *testing.T) {
 		t.Error("directory did not exist")
 	}
 
-	rc = vfsAccess(ctx, mod, 0, 8, _ACCESS_READWRITE, 4)
+	rc = vfsAccess(ctx, mod, 0, 8, ACCESS_READWRITE, 4)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -198,7 +199,7 @@ func Test_vfsAccess(t *testing.T) {
 	}
 
 	util.WriteString(mod, 8, file)
-	rc = vfsAccess(ctx, mod, 0, 8, _ACCESS_READWRITE, 4)
+	rc = vfsAccess(ctx, mod, 0, 8, ACCESS_READWRITE, 4)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
@@ -209,15 +210,20 @@ func Test_vfsAccess(t *testing.T) {
 
 func Test_vfsFile(t *testing.T) {
 	mod := util.NewMockModule(128)
-	ctx, vfs := Context(context.TODO())
+	ctx, vfs := NewContext(context.TODO())
 	defer vfs.Close()
 
 	// Open a temporary file.
-	rc := vfsOpen(ctx, mod, 0, 0, 4, _OPEN_CREATE|_OPEN_EXCLUSIVE|_OPEN_READWRITE|_OPEN_DELETEONCLOSE, 0)
+	rc := vfsOpen(ctx, mod, 0, 0, 4, OPEN_CREATE|OPEN_EXCLUSIVE|OPEN_READWRITE|OPEN_DELETEONCLOSE, 0)
 	if rc != _OK {
 		t.Fatal("returned", rc)
 	}
 
+	// Check sector size.
+	if size := vfsSectorSize(ctx, mod, 4); size != _DEFAULT_SECTOR_SIZE {
+		t.Fatal("returned", size)
+	}
+
 	// Write stuff.
 	text := "Hello world!"
 	util.WriteString(mod, 16, text)
@@ -274,3 +280,65 @@ func Test_vfsFile(t *testing.T) {
 		t.Fatal("returned", rc)
 	}
 }
+
+func Test_vfsFile_psow(t *testing.T) {
+	mod := util.NewMockModule(128)
+	ctx, vfs := NewContext(context.TODO())
+	defer vfs.Close()
+
+	// Open a temporary file.
+	rc := vfsOpen(ctx, mod, 0, 0, 4, OPEN_CREATE|OPEN_EXCLUSIVE|OPEN_READWRITE|OPEN_DELETEONCLOSE, 0)
+	if rc != _OK {
+		t.Fatal("returned", rc)
+	}
+
+	// Read powersafe overwrite.
+	util.WriteUint32(mod, 16, math.MaxUint32)
+	rc = vfsFileControl(ctx, mod, 4, _FCNTL_POWERSAFE_OVERWRITE, 16)
+	if rc != _OK {
+		t.Fatal("returned", rc)
+	}
+	if got := util.ReadUint32(mod, 16); got == 0 {
+		t.Error("psow disabled")
+	}
+
+	// Unset powersafe overwrite.
+	util.WriteUint32(mod, 16, 0)
+	rc = vfsFileControl(ctx, mod, 4, _FCNTL_POWERSAFE_OVERWRITE, 16)
+	if rc != _OK {
+		t.Fatal("returned", rc)
+	}
+
+	// Read powersafe overwrite.
+	util.WriteUint32(mod, 16, math.MaxUint32)
+	rc = vfsFileControl(ctx, mod, 4, _FCNTL_POWERSAFE_OVERWRITE, 16)
+	if rc != _OK {
+		t.Fatal("returned", rc)
+	}
+	if got := util.ReadUint32(mod, 16); got != 0 {
+		t.Error("psow enabled")
+	}
+
+	// Set powersafe overwrite.
+	util.WriteUint32(mod, 16, 1)
+	rc = vfsFileControl(ctx, mod, 4, _FCNTL_POWERSAFE_OVERWRITE, 16)
+	if rc != _OK {
+		t.Fatal("returned", rc)
+	}
+
+	// Read powersafe overwrite.
+	util.WriteUint32(mod, 16, math.MaxUint32)
+	rc = vfsFileControl(ctx, mod, 4, _FCNTL_POWERSAFE_OVERWRITE, 16)
+	if rc != _OK {
+		t.Fatal("returned", rc)
+	}
+	if got := util.ReadUint32(mod, 16); got == 0 {
+		t.Error("psow disabled")
+	}
+
+	// Close the file.
+	rc = vfsClose(ctx, mod, 4)
+	if rc != _OK {
+		t.Fatal("returned", rc)
+	}
+}

tests/conn_test.go

@@ -3,6 +3,7 @@ package tests
 import (
 	"context"
 	"errors"
+	"reflect"
 	"strings"
 	"testing"
 
@@ -58,6 +59,41 @@ func TestConn_Close_BUSY(t *testing.T) {
 	}
 }
 
+func TestConn_Pragma(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open("file::memory:?_pragma=busy_timeout(1000)")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	got, err := db.Pragma("busy_timeout")
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := []string{"1000"}
+
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("got %v, want %v", got, want)
+	}
+
+	var serr *sqlite3.Error
+	_, err = db.Pragma("+")
+	if err == nil {
+		t.Error("want: error")
+	}
+	if !errors.As(err, &serr) {
+		t.Fatalf("got %T, want sqlite3.Error", err)
+	}
+	if rc := serr.Code(); rc != sqlite3.ERROR {
+		t.Errorf("got %d, want sqlite3.ERROR", rc)
+	}
+	if got := err.Error(); got != `sqlite3: SQL logic error: near "+": syntax error` {
+		t.Error("got message:", got)
+	}
+}
+
 func TestConn_SetInterrupt(t *testing.T) {
 	t.Parallel()