vet fix.

Bumps [golang.org/x/sys](https://github.com/golang/sys) from 0.23.0 to 0.24.0.
- [Commits](https://github.com/golang/sys/compare/v0.23.0...v0.24.0)

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

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

.github/workflows/cross.yml

@@ -13,4 +13,4 @@ jobs:
       with: { go-version: stable }
 
     - name: Build
-      run: .github/workflows/cross.sh
+      run: .github/workflows/cross.sh

.github/workflows/repro.sh

@@ -2,29 +2,33 @@
 set -euo pipefail
 
 if [[ "$OSTYPE" == "linux"* ]]; then
-  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-22/wasi-sdk-22.0-linux.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_117/binaryen-version_117-x86_64-linux.tar.gz"
+  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-24/wasi-sdk-24.0-x86_64-linux.tar.gz"
+  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_118/binaryen-version_118-x86_64-linux.tar.gz"
 elif [[ "$OSTYPE" == "darwin"* ]]; then
-  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-22/wasi-sdk-22.0-macos.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_117/binaryen-version_117-x86_64-macos.tar.gz"
+  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-24/wasi-sdk-24.0-x86_64-macos.tar.gz"
+  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_118/binaryen-version_118-x86_64-macos.tar.gz"
 elif [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" ]]; then
-  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-22/wasi-sdk-22.0.m-mingw.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_117/binaryen-version_117-x86_64-windows.tar.gz"
+  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-24/wasi-sdk-24.0-x86_64-windows.tar.gz"
+  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_118/binaryen-version_118-x86_64-windows.tar.gz"
 fi
 
 # Download tools
 mkdir -p tools/
-[ -d "tools/wasi-sdk"* ]         || curl -#L "$WASI_SDK" | tar xzC tools &
-[ -d "tools/binaryen-version"* ] || curl -#L "$BINARYEN" | tar xzC tools &
+[ -d "tools/wasi-sdk" ] || curl -#L "$WASI_SDK" | tar xzC tools &
+[ -d "tools/binaryen" ] || curl -#L "$BINARYEN" | tar xzC tools &
 wait
 
+[ -d "tools/wasi-sdk" ] || mv "tools/wasi-sdk"* "tools/wasi-sdk"
+[ -d "tools/binaryen" ] || mv "tools/binaryen"* "tools/binaryen"
+
 # Download and build SQLite
 sqlite3/download.sh
 embed/build.sh
+embed/bcw2/build.sh
 
 # Download and build sqlite-createtable-parser
 util/vtabutil/parse/download.sh
 util/vtabutil/parse/build.sh
 
 # Check diffs
-git diff --exit-code 
+git diff --exit-code

.github/workflows/repro.yml

@@ -16,11 +16,13 @@ jobs:
     runs-on: ${{ matrix.os }}
 
     steps:
+    - uses: ilammy/msvc-dev-cmd@v1
     - uses: actions/checkout@v4
     - uses: actions/setup-go@v5
       with: { go-version: stable }
 
     - name: Build
+      shell: bash
       run: .github/workflows/repro.sh
 
     - uses: actions/attest-build-provenance@v1
@@ -28,4 +30,5 @@ jobs:
       with:
         subject-path: |
           embed/sqlite3.wasm
+          embed/bcw2/bcw2.wasm
           util/vtabutil/parse/sql3parse_table.wasm

.github/workflows/test.yml

@@ -36,7 +36,7 @@ jobs:
       run: go mod verify
 
     - name: Vet
-      run: go vet ./...
+      run: go vet -tags vet ./...
 
     - name: Build
       run: go build -v ./...
@@ -57,10 +57,20 @@ jobs:
       if: matrix.os == 'ubuntu-latest'
 
     - name: Test GORM
+      shell: bash
       run: gormlite/test.sh
 
+    - name: Collect coverage
+      run: |
+        go install github.com/dave/courtney@latest
+        courtney
+      if: |
+        github.event_name == 'push' &&
+        matrix.os == 'ubuntu-latest'
+
     - uses: ncruces/go-coverage-report@v0
       with:
+        coverage-file: coverage.out
         chart: true
         amend: true
       if: |
@@ -87,7 +97,7 @@ jobs:
       matrix:
         os:
           - name: freebsd
-            version: '14.0'
+            version: '14.1'
             flags: '-test.v'
           - name: openbsd
             version: '7.5'
@@ -113,7 +123,7 @@ jobs:
       run: .github/workflows/build-test.sh
 
     - name: Test
-      uses: cross-platform-actions/action@v0.24.0
+      uses: cross-platform-actions/action@v0.25.0
       with:
         operating_system: ${{ matrix.os.name }}
         version: ${{ matrix.os.version }}

README.md

@@ -93,7 +93,7 @@ This project aims for [high test coverage](https://github.com/ncruces/go-sqlite3
 It also benefits greatly from [SQLite's](https://sqlite.org/testing.html) and
 [wazero's](https://tetrate.io/blog/introducing-wazero-from-tetrate/#:~:text=Rock%2Dsolid%20test%20approach) thorough testing.
 
-Every commit is [tested](.github/workflows/test.yml) on
+Every commit is [tested](https://github.com/ncruces/go-sqlite3/wiki/Test-matrix) on
 Linux (amd64/arm64/386/riscv64/s390x), macOS (amd64/arm64),
 Windows (amd64), FreeBSD (amd64), OpenBSD (amd64), NetBSD (amd64),
 illumos (amd64), and Solaris (amd64).

blob.go

@@ -143,6 +143,7 @@ func (b *Blob) WriteTo(w io.Writer) (n int64, err error) {
 			return n, err
 		}
 		if int64(m) != want {
+			// notest // Write misbehaving
 			return n, io.ErrShortWrite
 		}
 

config.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/ncruces/go-sqlite3/vfs"
 	"github.com/tetratelabs/wazero/api"
 )
 
@@ -56,6 +57,99 @@ func logCallback(ctx context.Context, mod api.Module, _, iCode, zMsg uint32) {
 	}
 }
 
+// FileControl allows low-level control of database files.
+// Only a subset of opcodes are supported.
+//
+// https://sqlite.org/c3ref/file_control.html
+func (c *Conn) FileControl(schema string, op FcntlOpcode, arg ...any) (any, error) {
+	defer c.arena.mark()()
+
+	var schemaPtr uint32
+	if schema != "" {
+		schemaPtr = c.arena.string(schema)
+	}
+
+	switch op {
+	case FCNTL_RESET_CACHE:
+		r := c.call("sqlite3_file_control",
+			uint64(c.handle), uint64(schemaPtr),
+			uint64(op), 0)
+		return nil, c.error(r)
+
+	case FCNTL_PERSIST_WAL, FCNTL_POWERSAFE_OVERWRITE:
+		var flag int
+		switch {
+		case len(arg) == 0:
+			flag = -1
+		case arg[0]:
+			flag = 1
+		}
+		ptr := c.arena.new(4)
+		util.WriteUint32(c.mod, ptr, uint32(flag))
+		r := c.call("sqlite3_file_control",
+			uint64(c.handle), uint64(schemaPtr),
+			uint64(op), uint64(ptr))
+		return util.ReadUint32(c.mod, ptr) != 0, c.error(r)
+
+	case FCNTL_CHUNK_SIZE:
+		ptr := c.arena.new(4)
+		util.WriteUint32(c.mod, ptr, uint32(arg[0].(int)))
+		r := c.call("sqlite3_file_control",
+			uint64(c.handle), uint64(schemaPtr),
+			uint64(op), uint64(ptr))
+		return nil, c.error(r)
+
+	case FCNTL_RESERVE_BYTES:
+		bytes := -1
+		if len(arg) > 0 {
+			bytes = arg[0].(int)
+		}
+		ptr := c.arena.new(4)
+		util.WriteUint32(c.mod, ptr, uint32(bytes))
+		r := c.call("sqlite3_file_control",
+			uint64(c.handle), uint64(schemaPtr),
+			uint64(op), uint64(ptr))
+		return int(util.ReadUint32(c.mod, ptr)), c.error(r)
+
+	case FCNTL_DATA_VERSION:
+		ptr := c.arena.new(4)
+		r := c.call("sqlite3_file_control",
+			uint64(c.handle), uint64(schemaPtr),
+			uint64(op), uint64(ptr))
+		return util.ReadUint32(c.mod, ptr), c.error(r)
+
+	case FCNTL_LOCKSTATE:
+		ptr := c.arena.new(4)
+		r := c.call("sqlite3_file_control",
+			uint64(c.handle), uint64(schemaPtr),
+			uint64(op), uint64(ptr))
+		return vfs.LockLevel(util.ReadUint32(c.mod, ptr)), c.error(r)
+
+	case FCNTL_VFS_POINTER:
+		ptr := c.arena.new(4)
+		r := c.call("sqlite3_file_control",
+			uint64(c.handle), uint64(schemaPtr),
+			uint64(op), uint64(ptr))
+		const zNameOffset = 16
+		ptr = util.ReadUint32(c.mod, ptr)
+		ptr = util.ReadUint32(c.mod, ptr+zNameOffset)
+		name := util.ReadString(c.mod, ptr, _MAX_NAME)
+		return vfs.Find(name), c.error(r)
+
+	case FCNTL_FILE_POINTER, FCNTL_JOURNAL_POINTER:
+		ptr := c.arena.new(4)
+		r := c.call("sqlite3_file_control",
+			uint64(c.handle), uint64(schemaPtr),
+			uint64(op), uint64(ptr))
+		const fileHandleOffset = 4
+		ptr = util.ReadUint32(c.mod, ptr)
+		ptr = util.ReadUint32(c.mod, ptr+fileHandleOffset)
+		return util.GetHandle(c.ctx, ptr), c.error(r)
+	}
+
+	return nil, MISUSE
+}
+
 // Limit allows the size of various constructs to be
 // limited on a connection by connection basis.
 //
@@ -68,7 +162,7 @@ func (c *Conn) Limit(id LimitCategory, value int) int {
 // SetAuthorizer registers an authorizer callback with the database connection.
 //
 // https://sqlite.org/c3ref/set_authorizer.html
-func (c *Conn) SetAuthorizer(cb func(action AuthorizerActionCode, name3rd, name4th, schema, nameInner string) AuthorizerReturnCode) error {
+func (c *Conn) SetAuthorizer(cb func(action AuthorizerActionCode, name3rd, name4th, schema, inner string) AuthorizerReturnCode) error {
 	var enable uint64
 	if cb != nil {
 		enable = 1
@@ -82,9 +176,9 @@ func (c *Conn) SetAuthorizer(cb func(action AuthorizerActionCode, name3rd, name4
 
 }
 
-func authorizerCallback(ctx context.Context, mod api.Module, pDB uint32, action AuthorizerActionCode, zName3rd, zName4th, zSchema, zNameInner uint32) (rc AuthorizerReturnCode) {
+func authorizerCallback(ctx context.Context, mod api.Module, pDB uint32, action AuthorizerActionCode, zName3rd, zName4th, zSchema, zInner uint32) (rc AuthorizerReturnCode) {
 	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.authorizer != nil {
-		var name3rd, name4th, schema, nameInner string
+		var name3rd, name4th, schema, inner string
 		if zName3rd != 0 {
 			name3rd = util.ReadString(mod, zName3rd, _MAX_NAME)
 		}
@@ -94,10 +188,48 @@ func authorizerCallback(ctx context.Context, mod api.Module, pDB uint32, action
 		if zSchema != 0 {
 			schema = util.ReadString(mod, zSchema, _MAX_NAME)
 		}
-		if zNameInner != 0 {
-			nameInner = util.ReadString(mod, zNameInner, _MAX_NAME)
+		if zInner != 0 {
+			inner = util.ReadString(mod, zInner, _MAX_NAME)
+		}
+		rc = c.authorizer(action, name3rd, name4th, schema, inner)
+	}
+	return rc
+}
+
+// Trace registers a trace callback function against the database connection.
+//
+// https://sqlite.org/c3ref/trace_v2.html
+func (c *Conn) Trace(mask TraceEvent, cb func(evt TraceEvent, arg1 any, arg2 any) error) error {
+	r := c.call("sqlite3_trace_go", uint64(c.handle), uint64(mask))
+	if err := c.error(r); err != nil {
+		return err
+	}
+	c.trace = cb
+	return nil
+}
+
+func traceCallback(ctx context.Context, mod api.Module, evt TraceEvent, pDB, pArg1, pArg2 uint32) (rc uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.trace != nil {
+		var arg1, arg2 any
+		if evt == TRACE_CLOSE {
+			arg1 = c
+		} else {
+			for _, s := range c.stmts {
+				if pArg1 == s.handle {
+					arg1 = s
+					switch evt {
+					case TRACE_STMT:
+						arg2 = s.SQL()
+					case TRACE_PROFILE:
+						arg2 = int64(util.ReadUint64(mod, pArg2))
+					}
+					break
+				}
+			}
+		}
+		if arg1 != nil {
+			_, rc = errorCode(c.trace(evt, arg1, arg2), ERROR)
 		}
-		rc = c.authorizer(action, name3rd, name4th, schema, nameInner)
 	}
 	return rc
 }

conn.go

@@ -22,14 +22,16 @@ type Conn struct {
 
 	interrupt  context.Context
 	pending    *Stmt
+	stmts      []*Stmt
 	busy       func(int) bool
 	log        func(xErrorCode, string)
 	collation  func(*Conn, string)
+	wal        func(*Conn, string, int) error
+	trace      func(TraceEvent, any, any) error
 	authorizer func(AuthorizerActionCode, string, string, string, string) AuthorizerReturnCode
 	update     func(AuthorizerActionCode, string, string, int64)
 	commit     func() bool
 	rollback   func()
-	wal        func(*Conn, string, int) error
 	arena      arena
 
 	handle uint32
@@ -202,6 +204,7 @@ func (c *Conn) PrepareFlags(sql string, flags PrepareFlag) (stmt *Stmt, tail str
 	if stmt.handle == 0 {
 		return nil, "", nil
 	}
+	c.stmts = append(c.stmts, stmt)
 	return stmt, tail, nil
 }
 
@@ -227,9 +230,8 @@ func (c *Conn) Filename(schema string) *vfs.Filename {
 		defer c.arena.mark()()
 		ptr = c.arena.string(schema)
 	}
-
 	r := c.call("sqlite3_db_filename", uint64(c.handle), uint64(ptr))
-	return vfs.OpenFilename(c.ctx, c.mod, uint32(r), vfs.OPEN_MAIN_DB)
+	return vfs.GetFilename(c.ctx, c.mod, uint32(r), vfs.OPEN_MAIN_DB)
 }
 
 // ReadOnly determines if a database is read-only.
@@ -327,7 +329,12 @@ func (c *Conn) SetInterrupt(ctx context.Context) (old context.Context) {
 	// A busy SQL statement prevents SQLite from ignoring an interrupt
 	// that comes before any other statements are started.
 	if c.pending == nil {
-		c.pending, _, _ = c.Prepare(`WITH RECURSIVE c(x) AS (VALUES(0) UNION ALL SELECT x FROM c) SELECT x FROM c`)
+		defer c.arena.mark()()
+		stmtPtr := c.arena.new(ptrlen)
+		loopPtr := c.arena.string(`WITH RECURSIVE c(x) AS (VALUES(0) UNION ALL SELECT x FROM c) SELECT x FROM c`)
+		c.call("sqlite3_prepare_v3", uint64(c.handle), uint64(loopPtr), math.MaxUint64, 0, uint64(stmtPtr), 0)
+		c.pending = &Stmt{c: c}
+		c.pending.handle = util.ReadUint32(c.mod, stmtPtr)
 	}
 
 	old = c.interrupt
@@ -415,10 +422,74 @@ func busyCallback(ctx context.Context, mod api.Module, pDB uint32, count int32)
 	return retry
 }
 
+// Status retrieves runtime status information about a database connection.
+//
+// https://sqlite.org/c3ref/db_status.html
+func (c *Conn) Status(op DBStatus, reset bool) (current, highwater int, err error) {
+	defer c.arena.mark()()
+	hiPtr := c.arena.new(4)
+	curPtr := c.arena.new(4)
+
+	var i uint64
+	if reset {
+		i = 1
+	}
+
+	r := c.call("sqlite3_db_status", uint64(c.handle),
+		uint64(op), uint64(curPtr), uint64(hiPtr), i)
+	if err = c.error(r); err == nil {
+		current = int(util.ReadUint32(c.mod, curPtr))
+		highwater = int(util.ReadUint32(c.mod, hiPtr))
+	}
+	return
+}
+
+// TableColumnMetadata extracts metadata about a column of a table.
+//
+// https://sqlite.org/c3ref/table_column_metadata.html
+func (c *Conn) TableColumnMetadata(schema, table, column string) (declType, collSeq string, notNull, primaryKey, autoInc bool, err error) {
+	defer c.arena.mark()()
+
+	var schemaPtr, columnPtr uint32
+	declTypePtr := c.arena.new(ptrlen)
+	collSeqPtr := c.arena.new(ptrlen)
+	notNullPtr := c.arena.new(ptrlen)
+	primaryKeyPtr := c.arena.new(ptrlen)
+	autoIncPtr := c.arena.new(ptrlen)
+	if schema != "" {
+		schemaPtr = c.arena.string(schema)
+	}
+	tablePtr := c.arena.string(table)
+	if column != "" {
+		columnPtr = c.arena.string(column)
+	}
+
+	r := c.call("sqlite3_table_column_metadata", uint64(c.handle),
+		uint64(schemaPtr), uint64(tablePtr), uint64(columnPtr),
+		uint64(declTypePtr), uint64(collSeqPtr),
+		uint64(notNullPtr), uint64(primaryKeyPtr), uint64(autoIncPtr))
+	if err = c.error(r); err == nil && column != "" {
+		declType = util.ReadString(c.mod, util.ReadUint32(c.mod, declTypePtr), _MAX_NAME)
+		collSeq = util.ReadString(c.mod, util.ReadUint32(c.mod, collSeqPtr), _MAX_NAME)
+		notNull = util.ReadUint32(c.mod, notNullPtr) != 0
+		autoInc = util.ReadUint32(c.mod, autoIncPtr) != 0
+		primaryKey = util.ReadUint32(c.mod, primaryKeyPtr) != 0
+	}
+	return
+}
+
 func (c *Conn) error(rc uint64, sql ...string) error {
 	return c.sqlite.error(rc, c.handle, sql...)
 }
 
+func (c *Conn) stmtsIter(yield func(*Stmt) bool) {
+	for _, s := range c.stmts {
+		if !yield(s) {
+			break
+		}
+	}
+}
+
 // DriverConn is implemented by the SQLite [database/sql] driver connection.
 //
 // It can be used to access SQLite features like [online backup].

conn_iter.go

@@ -0,0 +1,11 @@
+//go:build (go1.23 || goexperiment.rangefunc) && !vet
+
+package sqlite3
+
+import "iter"
+
+// Stmts returns an iterator for the prepared statements
+// associated with the database connection.
+//
+// https://sqlite.org/c3ref/next_stmt.html
+func (c *Conn) Stmts() iter.Seq[*Stmt] { return c.stmtsIter }

conn_old.go

@@ -0,0 +1,9 @@
+//go:build !(go1.23 || goexperiment.rangefunc) || vet
+
+package sqlite3
+
+// Stmts returns an iterator for the prepared statements
+// associated with the database connection.
+//
+// https://sqlite.org/c3ref/next_stmt.html
+func (c *Conn) Stmts() func(func(*Stmt) bool) { return c.stmtsIter }

const.go

@@ -109,7 +109,7 @@ const (
 	CANTOPEN_ISDIR          ExtendedErrorCode = xErrorCode(CANTOPEN) | (2 << 8)
 	CANTOPEN_FULLPATH       ExtendedErrorCode = xErrorCode(CANTOPEN) | (3 << 8)
 	CANTOPEN_CONVPATH       ExtendedErrorCode = xErrorCode(CANTOPEN) | (4 << 8)
-	CANTOPEN_DIRTYWAL       ExtendedErrorCode = xErrorCode(CANTOPEN) | (5 << 8) /* Not Used */
+	// CANTOPEN_DIRTYWAL    ExtendedErrorCode = xErrorCode(CANTOPEN) | (5 << 8) /* Not Used */
 	CANTOPEN_SYMLINK        ExtendedErrorCode = xErrorCode(CANTOPEN) | (6 << 8)
 	CORRUPT_VTAB            ExtendedErrorCode = xErrorCode(CORRUPT) | (1 << 8)
 	CORRUPT_SEQUENCE        ExtendedErrorCode = xErrorCode(CORRUPT) | (2 << 8)
@@ -177,11 +177,11 @@ const (
 type FunctionFlag uint32
 
 const (
-	DETERMINISTIC  FunctionFlag = 0x000000800
-	DIRECTONLY     FunctionFlag = 0x000080000
-	SUBTYPE        FunctionFlag = 0x000100000
-	INNOCUOUS      FunctionFlag = 0x000200000
-	RESULT_SUBTYPE FunctionFlag = 0x001000000
+	DETERMINISTIC FunctionFlag = 0x000000800
+	DIRECTONLY    FunctionFlag = 0x000080000
+	INNOCUOUS     FunctionFlag = 0x000200000
+	// SUBTYPE        FunctionFlag = 0x000100000
+	// RESULT_SUBTYPE FunctionFlag = 0x001000000
 )
 
 // StmtStatus name counter values associated with the [Stmt.Status] method.
@@ -201,6 +201,27 @@ const (
 	STMTSTATUS_MEMUSED       StmtStatus = 99
 )
 
+// DBStatus are the available "verbs" that can be passed to the [Conn.Status] method.
+//
+// https://sqlite.org/c3ref/c_dbstatus_options.html
+type DBStatus uint32
+
+const (
+	DBSTATUS_LOOKASIDE_USED      DBStatus = 0
+	DBSTATUS_CACHE_USED          DBStatus = 1
+	DBSTATUS_SCHEMA_USED         DBStatus = 2
+	DBSTATUS_STMT_USED           DBStatus = 3
+	DBSTATUS_LOOKASIDE_HIT       DBStatus = 4
+	DBSTATUS_LOOKASIDE_MISS_SIZE DBStatus = 5
+	DBSTATUS_LOOKASIDE_MISS_FULL DBStatus = 6
+	DBSTATUS_CACHE_HIT           DBStatus = 7
+	DBSTATUS_CACHE_MISS          DBStatus = 8
+	DBSTATUS_CACHE_WRITE         DBStatus = 9
+	DBSTATUS_DEFERRED_FKS        DBStatus = 10
+	DBSTATUS_CACHE_USED_SHARED   DBStatus = 11
+	DBSTATUS_CACHE_SPILL         DBStatus = 12
+)
+
 // DBConfig are the available database connection configuration options.
 //
 // https://sqlite.org/c3ref/c_dbconfig_defensive.html
@@ -229,6 +250,24 @@ const (
 	DBCONFIG_REVERSE_SCANORDER     DBConfig = 1019
 )
 
+// FcntlOpcode are the available opcodes for [Conn.FileControl].
+//
+// https://sqlite.org/c3ref/c_fcntl_begin_atomic_write.html
+type FcntlOpcode uint32
+
+const (
+	FCNTL_LOCKSTATE           FcntlOpcode = 1
+	FCNTL_CHUNK_SIZE          FcntlOpcode = 6
+	FCNTL_FILE_POINTER        FcntlOpcode = 7
+	FCNTL_PERSIST_WAL         FcntlOpcode = 10
+	FCNTL_POWERSAFE_OVERWRITE FcntlOpcode = 13
+	FCNTL_VFS_POINTER         FcntlOpcode = 27
+	FCNTL_JOURNAL_POINTER     FcntlOpcode = 28
+	FCNTL_DATA_VERSION        FcntlOpcode = 35
+	FCNTL_RESERVE_BYTES       FcntlOpcode = 38
+	FCNTL_RESET_CACHE         FcntlOpcode = 42
+)
+
 // LimitCategory are the available run-time limit categories.
 //
 // https://sqlite.org/c3ref/c_limit_attached.html
@@ -289,8 +328,8 @@ const (
 	AUTH_DROP_VTABLE         AuthorizerActionCode = 30 /* Table Name      Module Name     */
 	AUTH_FUNCTION            AuthorizerActionCode = 31 /* NULL            Function Name   */
 	AUTH_SAVEPOINT           AuthorizerActionCode = 32 /* Operation       Savepoint Name  */
-	AUTH_COPY                AuthorizerActionCode = 0  /* No longer used */
 	AUTH_RECURSIVE           AuthorizerActionCode = 33 /* NULL            NULL            */
+	// AUTH_COPY             AuthorizerActionCode = 0  /* No longer used */
 )
 
 // AuthorizerReturnCode are the integer codes
@@ -328,6 +367,18 @@ const (
 	TXN_WRITE TxnState = 2
 )
 
+// TraceEvent identify classes of events that can be monitored with [Conn.Trace].
+//
+// https://sqlite.org/c3ref/c_trace.html
+type TraceEvent uint32
+
+const (
+	TRACE_STMT    TraceEvent = 0x01
+	TRACE_PROFILE TraceEvent = 0x02
+	TRACE_ROW     TraceEvent = 0x04
+	TRACE_CLOSE   TraceEvent = 0x08
+)
+
 // Datatype is a fundamental datatype of SQLite.
 //
 // https://sqlite.org/c3ref/c_blob.html

context.go

@@ -130,7 +130,8 @@ func (ctx Context) ResultNull() {
 //
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultTime(value time.Time, format TimeFormat) {
-	if format == TimeFormatDefault {
+	switch format {
+	case TimeFormatDefault, TimeFormatAuto, time.RFC3339Nano:
 		ctx.resultRFC3339Nano(value)
 		return
 	}
@@ -165,7 +166,8 @@ func (ctx Context) resultRFC3339Nano(value time.Time) {
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultPointer(ptr any) {
 	valPtr := util.AddHandle(ctx.c.ctx, ptr)
-	ctx.c.call("sqlite3_result_pointer_go", uint64(valPtr))
+	ctx.c.call("sqlite3_result_pointer_go",
+		uint64(ctx.handle), uint64(valPtr))
 }
 
 // ResultJSON sets the result of the function to the JSON encoding of value.
@@ -175,7 +177,7 @@ func (ctx Context) ResultJSON(value any) {
 	data, err := json.Marshal(value)
 	if err != nil {
 		ctx.ResultError(err)
-		return
+		return // notest
 	}
 	ctx.ResultRawText(data)
 }

driver/driver.go

@@ -8,21 +8,50 @@
 //
 // The data source name for "sqlite3" databases can be a filename or a "file:" [URI].
 //
+// # Default transaction mode
+//
 // The [TRANSACTION] mode can be specified using "_txlock":
 //
 //	sql.Open("sqlite3", "file:demo.db?_txlock=immediate")
 //
-// Possible values are: "deferred", "immediate", "exclusive".
-// A [read-only] transaction is always "deferred", regardless of "_txlock".
+// Possible values are: "deferred" (the default), "immediate", "exclusive".
+// Regardless of "_txlock":
+//   - a [linearizable] transaction is always "exclusive";
+//   - a [serializable] transaction is always "immediate";
+//   - a [read-only] transaction is always "deferred".
+//
+// # Working with time
 //
 // The time encoding/decoding format can be specified using "_timefmt":
 //
 //	sql.Open("sqlite3", "file:demo.db?_timefmt=sqlite")
 //
 // Possible values are: "auto" (the default), "sqlite", "rfc3339";
-// "auto" encodes as RFC 3339 and decodes any [format] supported by SQLite;
-// "sqlite" encodes as SQLite and decodes any [format] supported by SQLite;
-// "rfc3339" encodes and decodes RFC 3339 only.
+//   - "auto" encodes as RFC 3339 and decodes any [format] supported by SQLite;
+//   - "sqlite" encodes as SQLite and decodes any [format] supported by SQLite;
+//   - "rfc3339" encodes and decodes RFC 3339 only.
+//
+// If you encode as RFC 3339 (the default),
+// consider using the TIME [collating sequence] to produce a time-ordered sequence.
+//
+// To scan values in other formats, [sqlite3.TimeFormat.Scanner] may be helpful.
+// To bind values in other formats, [sqlite3.TimeFormat.Encode] them before binding.
+//
+// When using a custom time struct, you'll have to implement
+// [database/sql/driver.Valuer] and [database/sql.Scanner].
+//
+// The Value method should ideally serialise to a time [format] supported by SQLite.
+// This ensures SQL date and time functions work as they should,
+// and that your schema works with other SQLite tools.
+// [sqlite3.TimeFormat.Encode] may help.
+//
+// The Scan method needs to take into account that the value it receives can be of differing types.
+// It can already be a [time.Time], if the driver decoded the value according to "_timefmt" rules.
+// Or it can be a: string, int64, float64, []byte, nil,
+// depending on the column type and what whoever wrote the value.
+// [sqlite3.TimeFormat.Decode] may help.
+//
+// # Setting PRAGMAs
 //
 // [PRAGMA] statements can be specified using "_pragma":
 //
@@ -31,13 +60,17 @@
 // If no PRAGMAs are specified, a busy timeout of 1 minute is set.
 //
 // Order matters:
-// busy timeout and locking mode should be the first PRAGMAs set, in that order.
+// encryption keys, busy timeout and locking mode should be the first PRAGMAs set,
+// in that order.
 //
 // [URI]: https://sqlite.org/uri.html
 // [PRAGMA]: https://sqlite.org/pragma.html
-// [format]: https://sqlite.org/lang_datefunc.html#time_values
 // [TRANSACTION]: https://sqlite.org/lang_transaction.html#deferred_immediate_and_exclusive_transactions
+// [linearizable]: https://pkg.go.dev/database/sql#TxOptions
+// [serializable]: https://pkg.go.dev/database/sql#TxOptions
 // [read-only]: https://pkg.go.dev/database/sql#TxOptions
+// [format]: https://sqlite.org/lang_datefunc.html#time_values
+// [collating sequence]: https://sqlite.org/datatype3.html#collating_sequences
 package driver
 
 import (
@@ -69,11 +102,22 @@ func init() {
 
 // Open opens the SQLite database specified by dataSourceName as a [database/sql.DB].
 //
-// The init function is called by the driver on new connections.
+// Open accepts zero, one, or two callbacks (nil callbacks are ignored).
+// The first callback is called when the driver opens a new connection.
+// The second callback is called before the driver closes a connection.
 // The [sqlite3.Conn] can be used to execute queries, register functions, etc.
-// Any error returned closes the connection and is returned to [database/sql].
-func Open(dataSourceName string, init func(*sqlite3.Conn) error) (*sql.DB, error) {
-	c, err := (&SQLite{Init: init}).OpenConnector(dataSourceName)
+func Open(dataSourceName string, fn ...func(*sqlite3.Conn) error) (*sql.DB, error) {
+	var drv SQLite
+	if len(fn) > 2 {
+		return nil, sqlite3.MISUSE
+	}
+	if len(fn) > 1 {
+		drv.term = fn[1]
+	}
+	if len(fn) > 0 {
+		drv.init = fn[0]
+	}
+	c, err := drv.OpenConnector(dataSourceName)
 	if err != nil {
 		return nil, err
 	}
@@ -82,10 +126,8 @@ func Open(dataSourceName string, init func(*sqlite3.Conn) error) (*sql.DB, error
 
 // SQLite implements [database/sql/driver.Driver].
 type SQLite struct {
-	// Init function is called by the driver on new connections.
-	// The [sqlite3.Conn] can be used to execute queries, register functions, etc.
-	// Any error returned closes the connection and is returned to [database/sql].
-	Init func(*sqlite3.Conn) error
+	init func(*sqlite3.Conn) error
+	term func(*sqlite3.Conn) error
 }
 
 // Open implements [database/sql/driver.Driver].
@@ -119,10 +161,8 @@ func (d *SQLite) newConnector(name string) (*connector, error) {
 	}
 
 	switch txlock {
-	case "":
-		c.txBegin = "BEGIN"
-	case "deferred", "immediate", "exclusive":
-		c.txBegin = "BEGIN " + txlock
+	case "", "deferred", "concurrent", "immediate", "exclusive":
+		c.txLock = txlock
 	default:
 		return nil, fmt.Errorf("sqlite3: invalid _txlock: %s", txlock)
 	}
@@ -147,7 +187,7 @@ func (d *SQLite) newConnector(name string) (*connector, error) {
 type connector struct {
 	driver  *SQLite
 	name    string
-	txBegin string
+	txLock  string
 	tmRead  sqlite3.TimeFormat
 	tmWrite sqlite3.TimeFormat
 	pragmas bool
@@ -159,7 +199,7 @@ func (n *connector) Driver() driver.Driver {
 
 func (n *connector) Connect(ctx context.Context) (_ driver.Conn, err error) {
 	c := &conn{
-		txBegin: n.txBegin,
+		txLock:  n.txLock,
 		tmRead:  n.tmRead,
 		tmWrite: n.tmWrite,
 	}
@@ -178,18 +218,18 @@ func (n *connector) Connect(ctx context.Context) (_ driver.Conn, err error) {
 	defer c.Conn.SetInterrupt(old)
 
 	if !n.pragmas {
-		err = c.Conn.BusyTimeout(60 * time.Second)
+		err = c.Conn.BusyTimeout(time.Minute)
 		if err != nil {
 			return nil, err
 		}
 	}
-	if n.driver.Init != nil {
-		err = n.driver.Init(c.Conn)
+	if n.driver.init != nil {
+		err = n.driver.init(c.Conn)
 		if err != nil {
 			return nil, err
 		}
 	}
-	if n.pragmas || n.driver.Init != nil {
+	if n.pragmas || n.driver.init != nil {
 		s, _, err := c.Conn.Prepare(`PRAGMA query_only`)
 		if err != nil {
 			return nil, err
@@ -204,17 +244,24 @@ func (n *connector) Connect(ctx context.Context) (_ driver.Conn, err error) {
 			return nil, err
 		}
 	}
+	if n.driver.term != nil {
+		err = c.Conn.Trace(sqlite3.TRACE_CLOSE, func(sqlite3.TraceEvent, any, any) error {
+			return n.driver.term(c.Conn)
+		})
+		if err != nil {
+			return nil, err
+		}
+	}
 	return c, nil
 }
 
 type conn struct {
 	*sqlite3.Conn
-	txBegin    string
-	txCommit   string
-	txRollback string
-	tmRead     sqlite3.TimeFormat
-	tmWrite    sqlite3.TimeFormat
-	readOnly   byte
+	txLock   string
+	txReset  string
+	tmRead   sqlite3.TimeFormat
+	tmWrite  sqlite3.TimeFormat
+	readOnly byte
 }
 
 var (
@@ -231,31 +278,30 @@ func (c *conn) Raw() *sqlite3.Conn {
 
 // Deprecated: use BeginTx instead.
 func (c *conn) Begin() (driver.Tx, error) {
+	// notest
 	return c.BeginTx(context.Background(), driver.TxOptions{})
 }
 
 func (c *conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {
-	txBegin := c.txBegin
-	c.txCommit = `COMMIT`
-	c.txRollback = `ROLLBACK`
-
-	if opts.ReadOnly {
-		txBegin = `
-			BEGIN deferred;
-			PRAGMA query_only=on`
-		c.txRollback = `
-			ROLLBACK;
-			PRAGMA query_only=` + string(c.readOnly)
-		c.txCommit = c.txRollback
-	}
-
+	var txLock string
 	switch opts.Isolation {
 	default:
 		return nil, util.IsolationErr
-	case
-		driver.IsolationLevel(sql.LevelDefault),
-		driver.IsolationLevel(sql.LevelSerializable):
-		break
+	case driver.IsolationLevel(sql.LevelLinearizable):
+		txLock = "exclusive"
+	case driver.IsolationLevel(sql.LevelSerializable):
+		txLock = "immediate"
+	case driver.IsolationLevel(sql.LevelDefault):
+		if !opts.ReadOnly {
+			txLock = c.txLock
+		}
+	}
+
+	c.txReset = ``
+	txBegin := `BEGIN ` + txLock
+	if opts.ReadOnly {
+		txBegin += ` ; PRAGMA query_only=on`
+		c.txReset = `; PRAGMA query_only=` + string(c.readOnly)
 	}
 
 	old := c.Conn.SetInterrupt(ctx)
@@ -269,7 +315,7 @@ func (c *conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, e
 }
 
 func (c *conn) Commit() error {
-	err := c.Conn.Exec(c.txCommit)
+	err := c.Conn.Exec(`COMMIT` + c.txReset)
 	if err != nil && !c.Conn.GetAutocommit() {
 		c.Rollback()
 	}
@@ -277,16 +323,17 @@ func (c *conn) Commit() error {
 }
 
 func (c *conn) Rollback() error {
-	err := c.Conn.Exec(c.txRollback)
+	err := c.Conn.Exec(`ROLLBACK` + c.txReset)
 	if errors.Is(err, sqlite3.INTERRUPT) {
 		old := c.Conn.SetInterrupt(context.Background())
 		defer c.Conn.SetInterrupt(old)
-		err = c.Conn.Exec(c.txRollback)
+		err = c.Conn.Exec(`ROLLBACK` + c.txReset)
 	}
 	return err
 }
 
 func (c *conn) Prepare(query string) (driver.Stmt, error) {
+	// notest
 	return c.PrepareContext(context.Background(), query)
 }
 
@@ -329,6 +376,8 @@ func (c *conn) ExecContext(ctx context.Context, query string, args []driver.Name
 }
 
 func (c *conn) CheckNamedValue(arg *driver.NamedValue) error {
+	// Fast path: short circuit argument verification.
+	// Arguments will be rejected by conn.ExecContext.
 	return nil
 }
 
@@ -363,11 +412,13 @@ func (s *stmt) NumInput() int {
 
 // Deprecated: use ExecContext instead.
 func (s *stmt) Exec(args []driver.Value) (driver.Result, error) {
+	// notest
 	return s.ExecContext(context.Background(), namedValues(args))
 }
 
 // Deprecated: use QueryContext instead.
 func (s *stmt) Query(args []driver.Value) (driver.Rows, error) {
+	// notest
 	return s.QueryContext(context.Background(), namedValues(args))
 }
 
@@ -561,7 +612,8 @@ func (r *rows) Next(dest []driver.Value) error {
 }
 
 func (r *rows) decodeTime(i int, v any) (_ time.Time, ok bool) {
-	if r.tmRead == sqlite3.TimeFormatDefault {
+	switch r.tmRead {
+	case sqlite3.TimeFormatDefault, time.RFC3339Nano:
 		// handled by maybeTime
 		return
 	}

driver/driver_test.go

@@ -7,7 +7,6 @@ import (
 	"errors"
 	"math"
 	"net/url"
-	"path/filepath"
 	"testing"
 	"time"
 
@@ -15,9 +14,21 @@ import (
 	_ "github.com/ncruces/go-sqlite3/embed"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 	"github.com/ncruces/go-sqlite3/internal/util"
-	"github.com/ncruces/go-sqlite3/vfs"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
+func Test_Open_error(t *testing.T) {
+	t.Parallel()
+
+	_, err := Open("", nil, nil, nil)
+	if err == nil {
+		t.Error("want error")
+	}
+	if !errors.Is(err, sqlite3.MISUSE) {
+		t.Errorf("got %v, want sqlite3.MISUSE", err)
+	}
+}
+
 func Test_Open_dir(t *testing.T) {
 	t.Parallel()
 
@@ -38,8 +49,11 @@ func Test_Open_dir(t *testing.T) {
 
 func Test_Open_pragma(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t, url.Values{
+		"_pragma": {"busy_timeout(1000)"},
+	})
 
-	db, err := sql.Open("sqlite3", "file::memory:?_pragma=busy_timeout(1000)")
+	db, err := sql.Open("sqlite3", tmp)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -57,8 +71,11 @@ func Test_Open_pragma(t *testing.T) {
 
 func Test_Open_pragma_invalid(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t, url.Values{
+		"_pragma": {"busy_timeout 1000"},
+	})
 
-	db, err := sql.Open("sqlite3", "file::memory:?_pragma=busy_timeout+1000")
+	db, err := sql.Open("sqlite3", tmp)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -81,14 +98,13 @@ func Test_Open_pragma_invalid(t *testing.T) {
 }
 
 func Test_Open_txLock(t *testing.T) {
-	if !vfs.SupportsFileLocking {
-		t.Skip("skipping without locks")
-	}
 	t.Parallel()
+	tmp := memdb.TestDB(t, url.Values{
+		"_txlock": {"exclusive"},
+		"_pragma": {"busy_timeout(1000)"},
+	})
 
-	db, err := sql.Open("sqlite3", "file:"+
-		filepath.ToSlash(filepath.Join(t.TempDir(), "test.db"))+
-		"?_txlock=exclusive&_pragma=busy_timeout(0)")
+	db, err := sql.Open("sqlite3", tmp)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -119,8 +135,11 @@ func Test_Open_txLock(t *testing.T) {
 
 func Test_Open_txLock_invalid(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t, url.Values{
+		"_txlock": {"xclusive"},
+	})
 
-	_, err := sql.Open("sqlite3", "file::memory:?_txlock=xclusive")
+	_, err := sql.Open("sqlite3", tmp+"_txlock=xclusive")
 	if err == nil {
 		t.Fatal("want error")
 	}
@@ -130,17 +149,16 @@ func Test_Open_txLock_invalid(t *testing.T) {
 }
 
 func Test_BeginTx(t *testing.T) {
-	if !vfs.SupportsFileLocking {
-		t.Skip("skipping without locks")
-	}
 	t.Parallel()
+	tmp := memdb.TestDB(t, url.Values{
+		"_txlock": {"exclusive"},
+		"_pragma": {"busy_timeout(0)"},
+	})
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	db, err := sql.Open("sqlite3", "file:"+
-		filepath.ToSlash(filepath.Join(t.TempDir(), "test.db"))+
-		"?_txlock=exclusive&_pragma=busy_timeout(0)")
+	db, err := sql.Open("sqlite3", tmp)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -182,8 +200,9 @@ func Test_BeginTx(t *testing.T) {
 
 func Test_Prepare(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db, err := sql.Open("sqlite3", ":memory:")
+	db, err := sql.Open("sqlite3", tmp)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -222,11 +241,12 @@ func Test_Prepare(t *testing.T) {
 
 func Test_QueryRow_named(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	db, err := sql.Open("sqlite3", ":memory:")
+	db, err := sql.Open("sqlite3", tmp)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -274,8 +294,9 @@ func Test_QueryRow_named(t *testing.T) {
 
 func Test_QueryRow_blob_null(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db, err := sql.Open("sqlite3", ":memory:")
+	db, err := sql.Open("sqlite3", tmp)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -310,7 +331,11 @@ func Test_time(t *testing.T) {
 
 	for _, fmt := range []string{"auto", "sqlite", "rfc3339", time.ANSIC} {
 		t.Run(fmt, func(t *testing.T) {
-			db, err := sql.Open("sqlite3", "file::memory:?_timefmt="+url.QueryEscape(fmt))
+			tmp := memdb.TestDB(t, url.Values{
+				"_timefmt": {fmt},
+			})
+
+			db, err := sql.Open("sqlite3", tmp)
 			if err != nil {
 				t.Fatal(err)
 			}

driver/example_test.go

@@ -1,4 +1,4 @@
-//go:build (linux || darwin || windows || freebsd || illumos) && !sqlite3_nosys
+//go:build (linux || darwin || windows || freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock) && !sqlite3_nosys
 
 package driver_test
 
@@ -6,12 +6,16 @@ package driver_test
 
 import (
 	"database/sql"
+	"database/sql/driver"
 	"fmt"
 	"log"
 	"os"
+	"time"
 
+	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
+	_ "github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
 var db *sql.DB
@@ -149,3 +153,129 @@ func addAlbum(alb Album) (int64, error) {
 	}
 	return id, nil
 }
+
+func Example_customTime() {
+	db, err := sql.Open("sqlite3", "file:/time.db?vfs=memdb")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec(`
+		CREATE TABLE data (
+			id INTEGER PRIMARY KEY,
+			date_time TEXT
+		) STRICT;
+	`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// This one will be returned as string to [sql.Scanner] because it doesn't
+	// pass the driver's round-trip test when it tries to figure out if it's
+	// a time. 2009-11-17T20:34:58.650Z goes in, but parsing and formatting
+	// it with [time.RFC3338Nano] results in 2009-11-17T20:34:58.65Z. Though
+	// the times are identical, the trailing zero is lost in the string
+	// representation so the driver considers the conversion unsuccesful.
+	c1 := CustomTime{time.Date(
+		2009, 11, 17, 20, 34, 58, 650000000, time.UTC)}
+
+	// Store our custom time in the database.
+	_, err = db.Exec(`INSERT INTO data (date_time) VALUES(?)`, c1)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	var strc1 string
+	// Retrieve it as a string, the result of Value().
+	err = db.QueryRow(`
+		SELECT date_time
+		FROM data
+		WHERE id = last_insert_rowid()
+	`).Scan(&strc1)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println("in db:", strc1)
+
+	var resc1 CustomTime
+	// Retrieve it as our custom time type, going through Scan().
+	err = db.QueryRow(`
+		SELECT date_time
+		FROM data
+		WHERE id = last_insert_rowid()
+	`).Scan(&resc1)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println("custom time:", resc1)
+
+	// This one will be returned as [time.Time] to [sql.Scanner] because it does
+	// pass the driver's round-trip test when it tries to figure out if it's
+	// a time. 2009-11-17T20:34:58.651Z goes in, and parsing and formatting
+	// it with [time.RFC3339Nano] results in 2009-11-17T20:34:58.651Z.
+	c2 := CustomTime{time.Date(
+		2009, 11, 17, 20, 34, 58, 651000000, time.UTC)}
+	// Store our custom time in the database.
+	_, err = db.Exec(`INSERT INTO data (date_time) VALUES(?)`, c2)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	var strc2 string
+	// Retrieve it as a string, the result of Value().
+	err = db.QueryRow(`
+		SELECT date_time
+		FROM data
+		WHERE id = last_insert_rowid()
+	`).Scan(&strc2)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println("in db:", strc2)
+
+	var resc2 CustomTime
+	// Retrieve it as our custom time type, going through Scan().
+	err = db.QueryRow(`
+		SELECT date_time
+		FROM data
+		WHERE id = last_insert_rowid()
+	`).Scan(&resc2)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println("custom time:", resc2)
+	// Output:
+	// in db: 2009-11-17T20:34:58.650Z
+	// scan type string: 2009-11-17T20:34:58.650Z
+	// custom time: 2009-11-17 20:34:58.65 +0000 UTC
+	// in db: 2009-11-17T20:34:58.651Z
+	// scan type time: 2009-11-17 20:34:58.651 +0000 UTC
+	// custom time: 2009-11-17 20:34:58.651 +0000 UTC
+}
+
+type CustomTime struct{ time.Time }
+
+func (c CustomTime) Value() (driver.Value, error) {
+	return sqlite3.TimeFormat7TZ.Encode(c.UTC()), nil
+}
+
+func (c *CustomTime) Scan(value any) error {
+	switch v := value.(type) {
+	case nil:
+		*c = CustomTime{time.Time{}}
+	case time.Time:
+		fmt.Println("scan type time:", v)
+		*c = CustomTime{v}
+	case string:
+		fmt.Println("scan type string:", v)
+		t, err := sqlite3.TimeFormat7TZ.Decode(v)
+		if err != nil {
+			return err
+		}
+		*c = CustomTime{t}
+	default:
+		panic("unsupported value type")
+	}
+	return nil
+}

driver/json_test.go

@@ -11,7 +11,7 @@ import (
 )
 
 func Example_json() {
-	db, err := driver.Open("file:/test.db?vfs=memdb", nil)
+	db, err := driver.Open("file:/json.db?vfs=memdb")
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -21,8 +21,8 @@ func Example_json() {
 		CREATE TABLE orders (
 			cart_id INTEGER PRIMARY KEY,
 			user_id INTEGER NOT NULL,
-			cart    TEXT
-		);
+			cart    BLOB -- stored as JSONB
+		) STRICT;
 	`)
 	if err != nil {
 		log.Fatal(err)
@@ -39,7 +39,8 @@ func Example_json() {
 		Items []CartItem `json:"items"`
 	}
 
-	_, err = db.Exec(`INSERT INTO orders (user_id, cart) VALUES (?, ?)`, 123, sqlite3.JSON(Cart{
+	// convert to JSONB on insertion
+	_, err = db.Exec(`INSERT INTO orders (user_id, cart) VALUES (?, jsonb(?))`, 123, sqlite3.JSON(Cart{
 		[]CartItem{
 			{ItemID: "111", Name: "T-shirt", Quantity: 1, Price: 250},
 			{ItemID: "222", Name: "Trousers", Quantity: 1, Price: 600},
@@ -60,6 +61,24 @@ func Example_json() {
 	}
 
 	fmt.Println("total:", total)
+
+	var cart Cart
+	err = db.QueryRow(`
+		SELECT json(cart) -- convert to JSON on retrieval
+		FROM orders
+		WHERE cart_id = last_insert_rowid()
+	`).Scan(sqlite3.JSON(&cart))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	for _, item := range cart.Items {
+		fmt.Printf("id: %s, name: %s, quantity: %d, price: %d\n",
+			item.ItemID, item.Name, item.Quantity, item.Price)
+	}
+
 	// Output:
 	// total: 850
+	// id: 111, name: T-shirt, quantity: 1, price: 250
+	// id: 222, name: Trousers, quantity: 1, price: 600
 }

driver/savepoint.go

@@ -16,12 +16,25 @@ func Savepoint(tx *sql.Tx) sqlite3.Savepoint {
 	return ctx.Savepoint
 }
 
+// A saveptCtx is never canceled, has no values, and has no deadline.
 type saveptCtx struct{ sqlite3.Savepoint }
 
-func (*saveptCtx) Deadline() (deadline time.Time, ok bool) { return }
+func (*saveptCtx) Deadline() (deadline time.Time, ok bool) {
+	// notest
+	return
+}
 
-func (*saveptCtx) Done() <-chan struct{} { return nil }
+func (*saveptCtx) Done() <-chan struct{} {
+	// notest
+	return nil
+}
 
-func (*saveptCtx) Err() error { return nil }
+func (*saveptCtx) Err() error {
+	// notest
+	return nil
+}
 
-func (*saveptCtx) Value(key any) any { return nil }
+func (*saveptCtx) Value(key any) any {
+	// notest
+	return nil
+}

driver/savepoint_test.go

@@ -10,7 +10,7 @@ import (
 )
 
 func ExampleSavepoint() {
-	db, err := driver.Open("file:/test.db?vfs=memdb", nil)
+	db, err := driver.Open("file:/svpt.db?vfs=memdb")
 	if err != nil {
 		log.Fatal(err)
 	}

embed/README.md

@@ -1,6 +1,6 @@
 # Embeddable Wasm build of SQLite
 
-This folder includes an embeddable Wasm build of SQLite 3.46.0 for use with
+This folder includes an embeddable Wasm build of SQLite 3.46.1 for use with
 [`github.com/ncruces/go-sqlite3`](https://pkg.go.dev/github.com/ncruces/go-sqlite3).
 
 The following optional features are compiled in:
@@ -17,14 +17,24 @@ The following optional features are compiled in:
 - [regexp](https://github.com/sqlite/sqlite/blob/master/ext/misc/regexp.c)
 - [series](https://github.com/sqlite/sqlite/blob/master/ext/misc/series.c)
 - [uint](https://github.com/sqlite/sqlite/blob/master/ext/misc/uint.c)
-- [uuid](https://github.com/sqlite/sqlite/blob/master/ext/misc/uuid.c)
 - [time](../sqlite3/time.c)
 
-See the [configuration options](../sqlite3/sqlite_cfg.h),
+See the [configuration options](../sqlite3/sqlite_opt.h),
 and [patches](../sqlite3) applied.
 
 Built using [`wasi-sdk`](https://github.com/WebAssembly/wasi-sdk),
 and [`binaryen`](https://github.com/WebAssembly/binaryen).
 
 The build is easily reproducible, and verifiable, using
-[Artifact Attestations](https://github.com/ncruces/go-sqlite3/attestations).
+[Artifact Attestations](https://github.com/ncruces/go-sqlite3/attestations).
+
+### Customizing the build
+
+You can use your own custom build of SQLite.
+
+Examples of custom builds of SQLite are:
+- [`github.com/ncruces/go-sqlite3/embed/bcw2`](https://github.com/ncruces/go-sqlite3/tree/main/embed/bcw2)
+  built from a branch supporting [`BEGIN CONCURRENT`](https://sqlite.org/src/doc/begin-concurrent/doc/begin_concurrent.md)
+  and [Wal2](https://www.sqlite.org/cgi/src/doc/wal2/doc/wal2.md).
+- [`github.com/asg017/sqlite-vec-go-bindings/ncruces`](https://github.com/asg017/sqlite-vec-go-bindings)
+  which includes the [`sqlite-vec`](https://github.com/asg017/sqlite-vec) vector search extension.

embed/bcw2/README.md

@@ -0,0 +1,16 @@
+# Embeddable Wasm build of SQLite
+
+This folder includes an embeddable Wasm build of SQLite 3.46.1, including the experimental
+[`BEGIN CONCURRENT`](https://sqlite.org/src/doc/begin-concurrent/doc/begin_concurrent.md) and
+[Wal2](https://www.sqlite.org/cgi/src/doc/wal2/doc/wal2.md) patches.
+
+> [!IMPORTANT]  
+> This package is experimental.
+> It is built from the `bedrock` branch of SQLite,
+> since that is _currently_ the most stable, maintained branch to include both features.
+
+> [!CAUTION]
+> The Wal2 journaling mode creates databases that other versions of SQLite cannot access.
+
+The build is easily reproducible, and verifiable, using
+[Artifact Attestations](https://github.com/ncruces/go-sqlite3/attestations).

embed/bcw2/bcw2_test.go

@@ -0,0 +1,48 @@
+package bcw2
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/ncruces/go-sqlite3/driver"
+	"github.com/ncruces/go-sqlite3/vfs"
+)
+
+func Test_bcw2(t *testing.T) {
+	if !vfs.SupportsSharedMemory {
+		t.Skip("skipping without shared memory")
+	}
+
+	tmp := filepath.ToSlash(filepath.Join(t.TempDir(), "test.db"))
+
+	db, err := driver.Open("file:" + tmp + "?_pragma=journal_mode(wal2)&_txlock=concurrent")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	tx, err := db.Begin()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer tx.Rollback()
+
+	_, err = tx.Exec(`CREATE TABLE test (col)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = tx.Commit()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var version string
+	err = db.QueryRow(`SELECT sqlite_version()`).Scan(&version)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if version != "3.46.1" {
+		t.Error(version)
+	}
+}

embed/bcw2/build.sh

@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd -P -- "$(dirname -- "$0")"
+
+ROOT=../../
+BINARYEN="$ROOT/tools/binaryen/bin"
+WASI_SDK="$ROOT/tools/wasi-sdk/bin"
+
+trap 'rm -rf build/ sqlite/ bcw2.tmp' EXIT
+
+mkdir -p build/ext/
+cp "$ROOT"/sqlite3/*.[ch] build/
+cp "$ROOT"/sqlite3/*.patch build/
+
+curl -# https://www.sqlite.org/src/tarball/sqlite.tar.gz?r=bedrock-3.46 | tar xz
+
+cd sqlite
+if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" ]]; then
+	MSYS_NO_PATHCONV=1 nmake /f makefile.msc sqlite3.c
+else
+	sh configure
+	make sqlite3.c
+fi
+cd ~-
+
+mv sqlite/sqlite3.c             build/
+mv sqlite/sqlite3.h             build/
+mv sqlite/sqlite3ext.h          build/
+mv sqlite/ext/misc/anycollseq.c build/ext/
+mv sqlite/ext/misc/base64.c     build/ext/
+mv sqlite/ext/misc/decimal.c    build/ext/
+mv sqlite/ext/misc/ieee754.c    build/ext/
+mv sqlite/ext/misc/regexp.c     build/ext/
+mv sqlite/ext/misc/series.c     build/ext/
+mv sqlite/ext/misc/uint.c       build/ext/
+
+cd build
+cat *.patch | patch --no-backup-if-mismatch
+cd ~-
+
+"$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -g0 -O2 \
+	-Wall -Wextra -Wno-unused-parameter -Wno-unused-function \
+	-o bcw2.wasm "build/main.c" \
+	-I"build" \
+	-mexec-model=reactor \
+	-matomics -msimd128 -mmutable-globals \
+	-mbulk-memory -mreference-types \
+	-mnontrapping-fptoint -msign-ext \
+	-fno-stack-protector -fno-stack-clash-protection \
+	-Wl,--stack-first \
+	-Wl,--import-undefined \
+	-Wl,--initial-memory=327680 \
+	-D_HAVE_SQLITE_CONFIG_H \
+	-DSQLITE_CUSTOM_INCLUDE=sqlite_opt.h \
+	$(awk '{print "-Wl,--export="$0}' ../exports.txt)
+
+"$BINARYEN/wasm-ctor-eval" -g -c _initialize bcw2.wasm -o bcw2.tmp
+"$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
+	bcw2.tmp -o bcw2.wasm \
+	--enable-simd --enable-mutable-globals --enable-multivalue \
+	--enable-bulk-memory --enable-reference-types \
+	--enable-nontrapping-float-to-int --enable-sign-ext

embed/bcw2/init.go

@@ -0,0 +1,23 @@
+// Package bcw2 embeds SQLite into your application.
+//
+// Importing package bcw2 initializes the [sqlite3.Binary] variable
+// with a build of SQLite that includes the [BEGIN CONCURRENT] and [Wal2] patches:
+//
+//	import _ "github.com/ncruces/go-sqlite3/embed/bcw2"
+//
+// [BEGIN CONCURRENT]: https://sqlite.org/src/doc/begin-concurrent/doc/begin_concurrent.md
+// [Wal2]: https://www.sqlite.org/cgi/src/doc/wal2/doc/wal2.md
+package bcw2
+
+import (
+	_ "embed"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+//go:embed bcw2.wasm
+var binary []byte
+
+func init() {
+	sqlite3.Binary = binary
+}

embed/build.sh

@@ -4,26 +4,27 @@ set -euo pipefail
 cd -P -- "$(dirname -- "$0")"
 
 ROOT=../
-BINARYEN="$ROOT/tools/binaryen-version_117/bin"
-WASI_SDK="$ROOT/tools/wasi-sdk-22.0/bin"
+BINARYEN="$ROOT/tools/binaryen/bin"
+WASI_SDK="$ROOT/tools/wasi-sdk/bin"
 
-"$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -flto -g0 -O2 \
+trap 'rm -f sqlite3.tmp' EXIT
+
+"$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -g0 -O2 \
 	-Wall -Wextra -Wno-unused-parameter -Wno-unused-function \
 	-o sqlite3.wasm "$ROOT/sqlite3/main.c" \
 	-I"$ROOT/sqlite3" \
 	-mexec-model=reactor \
-	-msimd128 -mmutable-globals \
+	-matomics -msimd128 -mmutable-globals \
 	-mbulk-memory -mreference-types \
 	-mnontrapping-fptoint -msign-ext \
 	-fno-stack-protector -fno-stack-clash-protection \
-	-Wl,--initial-memory=327680 \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
+	-Wl,--initial-memory=327680 \
 	-D_HAVE_SQLITE_CONFIG_H \
 	-DSQLITE_CUSTOM_INCLUDE=sqlite_opt.h \
 	$(awk '{print "-Wl,--export="$0}' exports.txt)
 
-trap 'rm -f sqlite3.tmp' EXIT
 "$BINARYEN/wasm-ctor-eval" -g -c _initialize sqlite3.wasm -o sqlite3.tmp
 "$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
 	sqlite3.tmp -o sqlite3.wasm \

embed/exports.txt

@@ -55,17 +55,21 @@ sqlite3_create_function_go
 sqlite3_create_module_go
 sqlite3_create_window_function_go
 sqlite3_database_file_object
+sqlite3_db_cacheflush
 sqlite3_db_config
 sqlite3_db_filename
 sqlite3_db_name
 sqlite3_db_readonly
 sqlite3_db_release_memory
+sqlite3_db_status
 sqlite3_declare_vtab
 sqlite3_errcode
 sqlite3_errmsg
 sqlite3_error_offset
 sqlite3_errstr
 sqlite3_exec
+sqlite3_expanded_sql
+sqlite3_file_control
 sqlite3_filename_database
 sqlite3_filename_journal
 sqlite3_filename_wal
@@ -100,16 +104,18 @@ sqlite3_step
 sqlite3_stmt_busy
 sqlite3_stmt_readonly
 sqlite3_stmt_status
+sqlite3_table_column_metadata
 sqlite3_total_changes64
+sqlite3_trace_go
 sqlite3_txn_state
 sqlite3_update_hook_go
 sqlite3_uri_key
-sqlite3_uri_parameter
 sqlite3_value_blob
 sqlite3_value_bytes
 sqlite3_value_double
 sqlite3_value_dup
 sqlite3_value_free
+sqlite3_value_frombind
 sqlite3_value_int64
 sqlite3_value_nochange
 sqlite3_value_numeric_type

embed/init_test.go

@@ -0,0 +1,25 @@
+package embed
+
+import (
+	"testing"
+
+	"github.com/ncruces/go-sqlite3/driver"
+	_ "github.com/ncruces/go-sqlite3/vfs/memdb"
+)
+
+func Test_init(t *testing.T) {
+	db, err := driver.Open("file:/test.db?vfs=memdb")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	var version string
+	err = db.QueryRow(`SELECT sqlite_version()`).Scan(&version)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if version != "3.46.1" {
+		t.Error(version)
+	}
+}

error_test.go

@@ -2,6 +2,7 @@ package sqlite3
 
 import (
 	"errors"
+	"fmt"
 	"strings"
 	"testing"
 
@@ -10,7 +11,7 @@ import (
 
 func Test_assertErr(t *testing.T) {
 	err := util.AssertErr()
-	if s := err.Error(); !strings.HasPrefix(s, "sqlite3: assertion failed") || !strings.HasSuffix(s, "error_test.go:12)") {
+	if s := err.Error(); !strings.HasPrefix(s, "sqlite3: assertion failed") || !strings.HasSuffix(s, "error_test.go:13)") {
 		t.Errorf("got %q", s)
 	}
 }
@@ -166,3 +167,32 @@ func Test_ExtendedErrorCode_Error(t *testing.T) {
 		}
 	}
 }
+
+func Test_errorCode(t *testing.T) {
+	tests := []struct {
+		arg      error
+		wantMsg  string
+		wantCode uint32
+	}{
+		{nil, "", _OK},
+		{ERROR, "", util.ERROR},
+		{IOERR, "", util.IOERR},
+		{IOERR_READ, "", util.IOERR_READ},
+		{&Error{code: util.ERROR}, "", util.ERROR},
+		{fmt.Errorf("%w", ERROR), ERROR.Error(), util.ERROR},
+		{fmt.Errorf("%w", IOERR), IOERR.Error(), util.IOERR},
+		{fmt.Errorf("%w", IOERR_READ), IOERR_READ.Error(), util.IOERR_READ},
+		{fmt.Errorf("error"), "error", util.ERROR},
+	}
+	for _, tt := range tests {
+		t.Run("", func(t *testing.T) {
+			gotMsg, gotCode := errorCode(tt.arg, ERROR)
+			if gotMsg != tt.wantMsg {
+				t.Errorf("errorCode() gotMsg = %q, want %q", gotMsg, tt.wantMsg)
+			}
+			if gotCode != uint32(tt.wantCode) {
+				t.Errorf("errorCode() gotCode = %d, want %d", gotCode, tt.wantCode)
+			}
+		})
+	}
+}

ext/array/array.go

@@ -62,7 +62,7 @@ func (c *cursor) RowID() (int64, error) {
 	return int64(c.rowID), nil
 }
 
-func (c *cursor) Column(ctx *sqlite3.Context, n int) error {
+func (c *cursor) Column(ctx sqlite3.Context, n int) error {
 	if n != 0 {
 		return nil
 	}

ext/array/array_test.go

@@ -12,10 +12,11 @@ import (
 	_ "github.com/ncruces/go-sqlite3/embed"
 	"github.com/ncruces/go-sqlite3/ext/array"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
 func Example_driver() {
-	db, err := driver.Open(":memory:", array.Register)
+	db, err := driver.Open("file:/test.db?vfs=memdb", array.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -87,8 +88,9 @@ func Example() {
 
 func Test_cursor_Column(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db, err := driver.Open(":memory:", array.Register)
+	db, err := driver.Open(tmp, array.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -120,7 +122,7 @@ func Test_cursor_Column(t *testing.T) {
 		want = want[1:]
 	}
 	if err := rows.Err(); err != nil {
-		log.Fatal(err)
+		t.Fatal(err)
 	}
 }
 

ext/blobio/blob.go

@@ -43,13 +43,13 @@ func readblob(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	blob, err := getAuxBlob(ctx, arg, false)
 	if err != nil {
 		ctx.ResultError(err)
-		return
+		return // notest
 	}
 
 	_, err = blob.Seek(arg[4].Int64(), io.SeekStart)
 	if err != nil {
 		ctx.ResultError(err)
-		return
+		return // notest
 	}
 
 	n := arg[5].Int64()
@@ -61,7 +61,7 @@ func readblob(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	_, err = io.ReadFull(blob, buf)
 	if err != nil {
 		ctx.ResultError(err)
-		return
+		return // notest
 	}
 
 	ctx.ResultBlob(buf)
@@ -72,19 +72,23 @@ func writeblob(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	blob, err := getAuxBlob(ctx, arg, true)
 	if err != nil {
 		ctx.ResultError(err)
-		return
+		return // notest
 	}
 
 	_, err = blob.Seek(arg[4].Int64(), io.SeekStart)
 	if err != nil {
 		ctx.ResultError(err)
-		return
+		return // notest
 	}
 
-	_, err = blob.Write(arg[5].RawBlob())
+	if p, ok := arg[5].Pointer().(io.Reader); ok {
+		_, err = blob.ReadFrom(p)
+	} else {
+		_, err = blob.Write(arg[5].RawBlob())
+	}
 	if err != nil {
 		ctx.ResultError(err)
-		return
+		return // notest
 	}
 
 	setAuxBlob(ctx, blob, false)
@@ -99,14 +103,14 @@ func openblob(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	blob, err := getAuxBlob(ctx, arg, arg[4].Bool())
 	if err != nil {
 		ctx.ResultError(err)
-		return
+		return // notest
 	}
 
 	fn := arg[5].Pointer().(OpenCallback)
 	err = fn(blob, arg[6:]...)
 	if err != nil {
 		ctx.ResultError(err)
-		return
+		return // notest
 	}
 
 	setAuxBlob(ctx, blob, true)

ext/blobio/blob_test.go

@@ -5,6 +5,7 @@ import (
 	"log"
 	"os"
 	"reflect"
+	"strings"
 	"testing"
 
 	"github.com/ncruces/go-sqlite3"
@@ -47,7 +48,7 @@ func Example() {
 	// Read the BLOB.
 	_, err = db.Exec(`SELECT openblob('main', 'test', 'col', rowid, false, ?) FROM test`,
 		sqlite3.Pointer[blobio.OpenCallback](func(blob *sqlite3.Blob, _ ...sqlite3.Value) error {
-			_, err = io.Copy(os.Stdout, blob)
+			_, err = blob.WriteTo(os.Stdout)
 			return err
 		}))
 	if err != nil {
@@ -78,44 +79,135 @@ func Test_readblob(t *testing.T) {
 		t.Log(err)
 	}
 
+	err = db.Exec(`SELECT readblob('main', 'test1', 'col', 1, 1, 1)`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
 	err = db.Exec(`
 		CREATE TABLE test1 (col);
 		CREATE TABLE test2 (col);
 		INSERT INTO test1 VALUES (x'cafe');
+		INSERT INTO test1 VALUES (x'dead');
 		INSERT INTO test2 VALUES (x'babe');
 	`)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	stmt, _, err := db.Prepare(`SELECT readblob('main', value, 'col', 1, 1, 1) FROM array(?)`)
+	err = db.Exec(`SELECT readblob('main', 'test1', 'col', 1, -1, 1)`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`SELECT readblob('main', 'test1', 'col', 1, 1, 0)`)
+	if err != nil {
+		t.Log(err)
+	}
+
+	tests := []struct {
+		name  string
+		sql   string
+		want1 string
+		want2 string
+	}{
+		{"rows", `SELECT readblob('main', 'test1', 'col', rowid, 1, 1) FROM test1`, "\xfe", "\xad"},
+		{"tables", `SELECT readblob('main', value, 'col', 1, 1, 1) FROM array(?)`, "\xfe", "\xbe"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			stmt, _, err := db.Prepare(tt.sql)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer stmt.Close()
+
+			if stmt.BindCount() == 1 {
+				err = stmt.BindPointer(1, []string{"test1", "test2"})
+				if err != nil {
+					t.Fatal(err)
+				}
+			}
+
+			if stmt.Step() {
+				got := stmt.ColumnText(0)
+				if got != tt.want1 {
+					t.Errorf("got %q", got)
+				}
+			}
+
+			if stmt.Step() {
+				got := stmt.ColumnText(0)
+				if got != tt.want2 {
+					t.Errorf("got %q", got)
+				}
+			}
+
+			err = stmt.Err()
+			if err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func Test_writeblob(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
 	if err != nil {
 		t.Fatal(err)
 	}
+	defer db.Close()
+
+	err = db.Exec(`SELECT writeblob()`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`SELECT writeblob('main', 'test', 'col', 1, 1, x'')`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`
+		CREATE TABLE test (col);
+		INSERT INTO test VALUES (x'cafe');
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`SELECT writeblob('main', 'test', 'col', 1, -1, x'')`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT writeblob('main', 'test', 'col', 1, 0, ?)`)
+	if err != nil {
+		t.Log(err)
+	}
 	defer stmt.Close()
 
-	err = stmt.BindPointer(1, []string{"test1", "test2"})
+	err = stmt.BindPointer(1, strings.NewReader("\xba\xbe"))
 	if err != nil {
-		t.Fatal(err)
+		t.Log(err)
 	}
 
-	if stmt.Step() {
-		got := stmt.ColumnText(0)
-		if got != "\xfe" {
-			t.Errorf("got %q", got)
-		}
-	}
-
-	if stmt.Step() {
-		got := stmt.ColumnText(0)
-		if got != "\xbe" {
-			t.Errorf("got %q", got)
-		}
-	}
-
-	err = stmt.Err()
+	err = stmt.Exec()
 	if err != nil {
-		t.Fatal(err)
+		t.Log(err)
 	}
 }
 
@@ -135,6 +227,13 @@ func Test_openblob(t *testing.T) {
 		t.Log(err)
 	}
 
+	err = db.Exec(`SELECT openblob('main', 'test1', 'col', 1, false, NULL)`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
 	err = db.Exec(`
 		CREATE TABLE test1 (col);
 		CREATE TABLE test2 (col);

ext/bloom/bloom.go

@@ -129,10 +129,10 @@ func connect(db *sqlite3.Conn, _, schema, table string, arg ...string) (_ *bloom
 	defer load.Close()
 
 	if !load.Step() {
-		if err = load.Err(); err == nil {
-			err = sqlite3.CORRUPT_VTAB
+		if err := load.Err(); err != nil {
+			return nil, err
 		}
-		return nil, err
+		return nil, sqlite3.CORRUPT_VTAB
 	}
 
 	t.bytes = load.ColumnInt64(0)
@@ -160,7 +160,9 @@ func (b *bloom) Rename(new string) error {
 	return err
 }
 
-func (t *bloom) ShadowTables() {}
+func (t *bloom) ShadowTables() {
+	// notest // not meant to be called
+}
 
 func (t *bloom) Integrity(schema, table string, flags int) error {
 	load, _, err := t.db.Prepare(fmt.Sprintf(
@@ -218,6 +220,9 @@ func (b *bloom) Update(arg ...sqlite3.Value) (rowid int64, err error) {
 		return 0, util.ErrorString("bloom: elements cannot be updated")
 	}
 
+	if arg[2].NoChange() {
+		return 0, nil
+	}
 	blob := arg[2].RawBlob()
 
 	f, err := b.db.OpenBlob(b.schema, b.storage, "data", 1, true)
@@ -302,7 +307,10 @@ func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
 	return nil
 }
 
-func (c *cursor) Column(ctx *sqlite3.Context, n int) error {
+func (c *cursor) Column(ctx sqlite3.Context, n int) error {
+	if ctx.VTabNoChange() {
+		return nil
+	}
 	switch n {
 	case 0:
 		ctx.ResultBool(true)
@@ -322,6 +330,7 @@ func (c *cursor) EOF() bool {
 }
 
 func (c *cursor) RowID() (int64, error) {
+	// notest // WITHOUT ROWID
 	return 0, nil
 }
 

ext/bloom/bloom_test.go

@@ -26,7 +26,7 @@ func TestRegister(t *testing.T) {
 	defer db.Close()
 
 	err = db.Exec(`
-		CREATE VIRTUAL TABLE sports_cars USING bloom_filter(20);
+		CREATE VIRTUAL TABLE sports_cars USING bloom_filter();
 		INSERT INTO sports_cars VALUES ('ferrari'), ('lamborghini'), ('alfa romeo')
 	`)
 	if err != nil {
@@ -68,7 +68,22 @@ func TestRegister(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	err = db.Exec(`DROP TABLE sports_cars`)
+	err = db.Exec(`DELETE FROM sports_cars WHERE word = 'lamborghini'`)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	err = db.Exec(`UPDATE sports_cars SET word = 'ferrari' WHERE word = 'lamborghini'`)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	err = db.Exec(`ALTER TABLE sports_cars RENAME TO fast_cars`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`DROP TABLE fast_cars`)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -138,3 +153,42 @@ func Test_compatible(t *testing.T) {
 		t.Error(err)
 	}
 }
+
+func Test_errors(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	bloom.Register(db)
+
+	err = db.Exec(`CREATE VIRTUAL TABLE sports_cars USING bloom_filter(0)`)
+	if err == nil {
+		t.Error("want error")
+	}
+	err = db.Exec(`CREATE VIRTUAL TABLE sports_cars USING bloom_filter('a')`)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE sports_cars USING bloom_filter(20, 2)`)
+	if err == nil {
+		t.Error("want error")
+	}
+	err = db.Exec(`CREATE VIRTUAL TABLE sports_cars USING bloom_filter(20, 'a')`)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE sports_cars USING bloom_filter(20, 0.9, 0)`)
+	if err == nil {
+		t.Error("want error")
+	}
+	err = db.Exec(`CREATE VIRTUAL TABLE sports_cars USING bloom_filter(20, 0.9, 'a')`)
+	if err == nil {
+		t.Error("want error")
+	}
+}

ext/csv/csv.go

@@ -239,7 +239,7 @@ func (c *cursor) RowID() (int64, error) {
 	return c.rowID, nil
 }
 
-func (c *cursor) Column(ctx *sqlite3.Context, col int) error {
+func (c *cursor) Column(ctx sqlite3.Context, col int) error {
 	if col < len(c.row) {
 		typ := text
 		if col < len(c.table.typs) {

ext/fileio/coro.go

@@ -1,3 +1,5 @@
+//go:build !(go1.23 || goexperiment.rangefunc) || vet
+
 package fileio
 
 import (

ext/fileio/fileio.go

@@ -55,7 +55,7 @@ func readfile(fsys fs.FS) func(ctx sqlite3.Context, arg ...sqlite3.Value) {
 		case err == nil:
 			ctx.ResultBlob(data)
 		case !errors.Is(err, fs.ErrNotExist):
-			ctx.ResultError(fmt.Errorf("readfile: %w", err))
+			ctx.ResultError(fmt.Errorf("readfile: %w", err)) // notest
 		}
 	}
 }

ext/fileio/fileio_test.go

@@ -12,12 +12,14 @@ import (
 	_ "github.com/ncruces/go-sqlite3/embed"
 	"github.com/ncruces/go-sqlite3/ext/fileio"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
 func Test_lsmode(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db, err := driver.Open(":memory:", fileio.Register)
+	db, err := driver.Open(tmp, fileio.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -51,7 +53,9 @@ func Test_readfile(t *testing.T) {
 
 	for _, fsys := range []fs.FS{nil, os.DirFS(".")} {
 		t.Run("", func(t *testing.T) {
-			db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
+			tmp := memdb.TestDB(t)
+
+			db, err := driver.Open(tmp, func(c *sqlite3.Conn) error {
 				fileio.RegisterFS(c, fsys)
 				return nil
 			})

ext/fileio/fsdir.go

@@ -54,7 +54,7 @@ func (d fsdir) Open() (sqlite3.VTabCursor, error) {
 type cursor struct {
 	fsdir
 	base   string
-	resume func(struct{}) (entry, bool)
+	resume resume
 	cancel func()
 	curr   entry
 	eof    bool
@@ -92,25 +92,14 @@ func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
 		c.base = base
 	}
 
-	c.resume, c.cancel = coroNew(func(_ struct{}, yield func(entry) struct{}) entry {
-		walkDir := func(path string, d fs.DirEntry, err error) error {
-			yield(entry{d, err, path})
-			return nil
-		}
-		if c.fsys != nil {
-			fs.WalkDir(c.fsys, root, walkDir)
-		} else {
-			filepath.WalkDir(root, walkDir)
-		}
-		return entry{}
-	})
+	c.resume, c.cancel = pull(c, root)
 	c.eof = false
 	c.rowID = 0
 	return c.Next()
 }
 
 func (c *cursor) Next() error {
-	curr, ok := c.resume(struct{}{})
+	curr, ok := next(c)
 	c.curr = curr
 	c.eof = !ok
 	c.rowID++
@@ -125,7 +114,7 @@ func (c *cursor) RowID() (int64, error) {
 	return c.rowID, nil
 }
 
-func (c *cursor) Column(ctx *sqlite3.Context, n int) error {
+func (c *cursor) Column(ctx sqlite3.Context, n int) error {
 	switch n {
 	case 0: // name
 		name := strings.TrimPrefix(c.curr.path, c.base)

ext/fileio/fsdir_coro.go

@@ -0,0 +1,29 @@
+//go:build !(go1.23 || goexperiment.rangefunc) || vet
+
+package fileio
+
+import (
+	"io/fs"
+	"path/filepath"
+)
+
+type resume = func(struct{}) (entry, bool)
+
+func next(c *cursor) (entry, bool) {
+	return c.resume(struct{}{})
+}
+
+func pull(c *cursor, root string) (resume, func()) {
+	return coroNew(func(_ struct{}, yield func(entry) struct{}) entry {
+		walkDir := func(path string, d fs.DirEntry, err error) error {
+			yield(entry{d, err, path})
+			return nil
+		}
+		if c.fsys != nil {
+			fs.WalkDir(c.fsys, root, walkDir)
+		} else {
+			filepath.WalkDir(root, walkDir)
+		}
+		return entry{}
+	})
+}

ext/fileio/fsdir_iter.go

@@ -0,0 +1,31 @@
+//go:build (go1.23 || goexperiment.rangefunc) && !vet
+
+package fileio
+
+import (
+	"io/fs"
+	"iter"
+	"path/filepath"
+)
+
+type resume = func() (entry, bool)
+
+func next(c *cursor) (entry, bool) {
+	return c.resume()
+}
+
+func pull(c *cursor, root string) (resume, func()) {
+	return iter.Pull(func(yield func(entry) bool) {
+		walkDir := func(path string, d fs.DirEntry, err error) error {
+			if yield(entry{d, err, path}) {
+				return nil
+			}
+			return fs.SkipAll
+		}
+		if c.fsys != nil {
+			fs.WalkDir(c.fsys, root, walkDir)
+		} else {
+			filepath.WalkDir(root, walkDir)
+		}
+	})
+}

ext/fileio/fsdir_test.go

@@ -13,6 +13,7 @@ import (
 	_ "github.com/ncruces/go-sqlite3/embed"
 	"github.com/ncruces/go-sqlite3/ext/fileio"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
 func Test_fsdir(t *testing.T) {
@@ -20,7 +21,9 @@ func Test_fsdir(t *testing.T) {
 
 	for _, fsys := range []fs.FS{nil, os.DirFS(".")} {
 		t.Run("", func(t *testing.T) {
-			db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
+			tmp := memdb.TestDB(t)
+
+			db, err := driver.Open(tmp, func(c *sqlite3.Conn) error {
 				fileio.RegisterFS(c, fsys)
 				return nil
 			})

ext/fileio/write.go

@@ -29,7 +29,7 @@ func writefile(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	n, err := createFileAndDir(file, mode, arg[1])
 	if err != nil {
 		if len(arg) > 2 {
-			ctx.ResultError(fmt.Errorf("writefile: %w", err))
+			ctx.ResultError(fmt.Errorf("writefile: %w", err)) // notest
 		}
 		return
 	}
@@ -39,7 +39,7 @@ func writefile(ctx sqlite3.Context, arg ...sqlite3.Value) {
 			err := os.Chmod(file, mode.Perm())
 			if err != nil {
 				ctx.ResultError(fmt.Errorf("writefile: %w", err))
-				return
+				return // notest
 			}
 		}
 
@@ -48,7 +48,7 @@ func writefile(ctx sqlite3.Context, arg ...sqlite3.Value) {
 			err := os.Chtimes(file, time.Time{}, mtime)
 			if err != nil {
 				ctx.ResultError(fmt.Errorf("writefile: %w", err))
-				return
+				return // notest
 			}
 		}
 	}

ext/fileio/write_test.go

@@ -10,12 +10,14 @@ import (
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
 func Test_writefile(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db, err := driver.Open(":memory:", Register)
+	db, err := driver.Open(tmp, Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/hash/hash_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 	_ "golang.org/x/crypto/blake2b"
 	_ "golang.org/x/crypto/blake2s"
 	_ "golang.org/x/crypto/md4"
@@ -19,6 +20,7 @@ import (
 
 func TestRegister(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
 	tests := []struct {
 		name string
@@ -52,7 +54,7 @@ func TestRegister(t *testing.T) {
 		{"blake2b('', 256)", "0E5751C026E543B2E8AB2EB06099DAA1D1E5DF47778F7787FAAB45CDF12FE3A8"},
 	}
 
-	db, err := driver.Open(":memory:", Register)
+	db, err := driver.Open(tmp, Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/lines/lines.go

@@ -91,7 +91,7 @@ func (c *cursor) RowID() (int64, error) {
 	return c.rowID, nil
 }
 
-func (c *cursor) Column(ctx *sqlite3.Context, n int) error {
+func (c *cursor) Column(ctx sqlite3.Context, n int) error {
 	if n == 0 {
 		ctx.ResultRawText(c.line)
 	}

ext/lines/lines_test.go

@@ -15,10 +15,11 @@ import (
 	_ "github.com/ncruces/go-sqlite3/embed"
 	"github.com/ncruces/go-sqlite3/ext/lines"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
 func Example() {
-	db, err := driver.Open(":memory:", lines.Register)
+	db, err := driver.Open("file:/test.db?vfs=memdb", lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -66,8 +67,9 @@ func Example() {
 
 func Test_lines(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db, err := driver.Open(":memory:", lines.Register)
+	db, err := driver.Open(tmp, lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -96,8 +98,9 @@ func Test_lines(t *testing.T) {
 
 func Test_lines_error(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db, err := driver.Open(":memory:", lines.Register)
+	db, err := driver.Open(tmp, lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -120,8 +123,9 @@ func Test_lines_error(t *testing.T) {
 
 func Test_lines_read(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db, err := driver.Open(":memory:", lines.Register)
+	db, err := driver.Open(tmp, lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -151,8 +155,9 @@ func Test_lines_read(t *testing.T) {
 
 func Test_lines_test(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db, err := driver.Open(":memory:", lines.Register)
+	db, err := driver.Open(tmp, lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}

ext/pivot/pivot.go

@@ -225,7 +225,7 @@ func (c *cursor) RowID() (int64, error) {
 	return c.rowID, nil
 }
 
-func (c *cursor) Column(ctx *sqlite3.Context, col int) error {
+func (c *cursor) Column(ctx sqlite3.Context, col int) error {
 	count := c.scan.ColumnCount()
 	if col < count {
 		ctx.ResultValue(c.scan.ColumnValue(col))

ext/pivot/pivot_test.go

@@ -144,6 +144,11 @@ func TestRegister(t *testing.T) {
 			t.Errorf("got %d, want 3", got)
 		}
 	}
+
+	err = db.Exec(`ALTER TABLE v_x RENAME TO v_y`)
+	if err != nil {
+		t.Fatal(err)
+	}
 }
 
 func TestRegister_errors(t *testing.T) {

ext/regexp/regexp.go

@@ -44,7 +44,7 @@ func load(ctx sqlite3.Context, i int, expr string) (*regexp.Regexp, error) {
 func regex(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	re, err := load(ctx, 0, arg[0].Text())
 	if err != nil {
-		ctx.ResultError(err)
+		ctx.ResultError(err) // notest
 	} else {
 		ctx.ResultBool(re.Match(arg[1].RawText()))
 	}
@@ -53,7 +53,7 @@ func regex(ctx sqlite3.Context, arg ...sqlite3.Value) {
 func regexLike(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	re, err := load(ctx, 1, arg[1].Text())
 	if err != nil {
-		ctx.ResultError(err)
+		ctx.ResultError(err) // notest
 	} else {
 		ctx.ResultBool(re.Match(arg[0].RawText()))
 	}
@@ -62,7 +62,7 @@ func regexLike(ctx sqlite3.Context, arg ...sqlite3.Value) {
 func regexSubstr(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	re, err := load(ctx, 1, arg[1].Text())
 	if err != nil {
-		ctx.ResultError(err)
+		ctx.ResultError(err) // notest
 	} else {
 		ctx.ResultRawText(re.Find(arg[0].RawText()))
 	}
@@ -71,7 +71,7 @@ func regexSubstr(ctx sqlite3.Context, arg ...sqlite3.Value) {
 func regexReplace(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	re, err := load(ctx, 1, arg[1].Text())
 	if err != nil {
-		ctx.ResultError(err)
+		ctx.ResultError(err) // notest
 	} else {
 		ctx.ResultRawText(re.ReplaceAll(arg[0].RawText(), arg[2].RawText()))
 	}

ext/regexp/regexp_test.go

@@ -6,12 +6,14 @@ import (
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
 func TestRegister(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db, err := driver.Open(":memory:", Register)
+	db, err := driver.Open(tmp, Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -45,8 +47,9 @@ func TestRegister(t *testing.T) {
 
 func TestRegister_errors(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db, err := driver.Open(":memory:", Register)
+	db, err := driver.Open(tmp, Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/statement/stmt.go

@@ -123,12 +123,11 @@ func (t *table) BestIndex(idx *sqlite3.IndexInfo) error {
 	return nil
 }
 
-func (t *table) Open() (sqlite3.VTabCursor, error) {
+func (t *table) Open() (_ sqlite3.VTabCursor, err error) {
 	stmt := t.stmt
 	if !t.inuse {
 		t.inuse = true
 	} else {
-		var err error
 		stmt, _, err = t.stmt.Conn().Prepare(t.sql)
 		if err != nil {
 			return nil, err
@@ -202,7 +201,7 @@ func (c *cursor) RowID() (int64, error) {
 	return c.rowID, nil
 }
 
-func (c *cursor) Column(ctx *sqlite3.Context, col int) error {
+func (c *cursor) Column(ctx sqlite3.Context, col int) error {
 	switch outputs := c.stmt.ColumnCount(); {
 	case col < outputs:
 		ctx.ResultValue(c.stmt.ColumnValue(col))

ext/stats/percentile.go

@@ -62,7 +62,7 @@ func (q *percentile) Value(ctx sqlite3.Context) {
 		ctx.ResultJSON(floats)
 	}
 	if err != nil {
-		ctx.ResultError(fmt.Errorf("percentile: %w", err))
+		ctx.ResultError(fmt.Errorf("percentile: %w", err)) // notest
 	}
 }
 

ext/unicode/unicode.go

@@ -51,7 +51,7 @@ func Register(db *sqlite3.Conn) error {
 				err := RegisterCollation(db, arg[0].Text(), name)
 				if err != nil {
 					ctx.ResultError(err)
-					return
+					return // notest
 				}
 			}))
 }
@@ -75,7 +75,7 @@ func upper(ctx sqlite3.Context, arg ...sqlite3.Value) {
 		t, err := language.Parse(arg[1].Text())
 		if err != nil {
 			ctx.ResultError(err)
-			return
+			return // notest
 		}
 		c := cases.Upper(t)
 		ctx.SetAuxData(1, c)
@@ -94,7 +94,7 @@ func lower(ctx sqlite3.Context, arg ...sqlite3.Value) {
 		t, err := language.Parse(arg[1].Text())
 		if err != nil {
 			ctx.ResultError(err)
-			return
+			return // notest
 		}
 		c := cases.Lower(t)
 		ctx.SetAuxData(1, c)
@@ -109,7 +109,7 @@ func regex(ctx sqlite3.Context, arg ...sqlite3.Value) {
 		r, err := regexp.Compile(arg[0].Text())
 		if err != nil {
 			ctx.ResultError(err)
-			return
+			return // notest
 		}
 		re = r
 		ctx.SetAuxData(0, r)

ext/uuid/uuid.go

@@ -107,7 +107,7 @@ func generate(ctx sqlite3.Context, arg ...sqlite3.Value) {
 				ns = uuid.NameSpaceX500
 			default:
 				ctx.ResultError(err)
-				return
+				return // notest
 			}
 		}
 		if ver == 3 {
@@ -121,7 +121,7 @@ func generate(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	}
 
 	if err != nil {
-		ctx.ResultError(fmt.Errorf("uuid: %w", err))
+		ctx.ResultError(fmt.Errorf("uuid: %w", err)) // notest
 	} else {
 		ctx.ResultText(u.String())
 	}
@@ -152,7 +152,7 @@ func fromValue(arg sqlite3.Value) (u uuid.UUID, err error) {
 func toBlob(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	u, err := fromValue(arg[0])
 	if err != nil {
-		ctx.ResultError(err)
+		ctx.ResultError(err) // notest
 	} else {
 		ctx.ResultBlob(u[:])
 	}
@@ -161,7 +161,7 @@ func toBlob(ctx sqlite3.Context, arg ...sqlite3.Value) {
 func toString(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	u, err := fromValue(arg[0])
 	if err != nil {
-		ctx.ResultError(err)
+		ctx.ResultError(err) // notest
 	} else {
 		ctx.ResultText(u.String())
 	}

ext/uuid/uuid_test.go

@@ -7,12 +7,14 @@ import (
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
 func Test_generate(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db, err := driver.Open(":memory:", Register)
+	db, err := driver.Open(tmp, Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -130,8 +132,9 @@ func Test_generate(t *testing.T) {
 
 func Test_convert(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db, err := driver.Open(":memory:", Register)
+	db, err := driver.Open(tmp, Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/zorder/zorder.go

@@ -20,17 +20,17 @@ func Register(db *sqlite3.Conn) error {
 
 func zorder(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	var x [63]int64
-	for i := range arg {
-		x[i] = arg[i].Int64()
-	}
 	if len(arg) > len(x) {
 		ctx.ResultError(util.ErrorString("zorder: too many parameters"))
 		return
 	}
+	for i := range arg {
+		x[i] = arg[i].Int64()
+	}
 
 	var z int64
 	if len(arg) > 0 {
-		for i := 0; i < 63; i++ {
+		for i := range x {
 			j := i % len(arg)
 			z |= (x[j] & 1) << i
 			x[j] >>= 1

ext/zorder/zorder_test.go

@@ -1,18 +1,22 @@
 package zorder_test
 
 import (
+	"strconv"
+	"strings"
 	"testing"
 
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	"github.com/ncruces/go-sqlite3/ext/zorder"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
 func TestRegister_zorder(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db, err := driver.Open(":memory:", zorder.Register)
+	db, err := driver.Open(tmp, zorder.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -55,8 +59,9 @@ func TestRegister_zorder(t *testing.T) {
 
 func TestRegister_unzorder(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db, err := driver.Open(":memory:", zorder.Register)
+	db, err := driver.Open(tmp, zorder.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -82,8 +87,9 @@ func TestRegister_unzorder(t *testing.T) {
 
 func TestRegister_error(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db, err := driver.Open(":memory:", zorder.Register)
+	db, err := driver.Open(tmp, zorder.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -94,4 +100,16 @@ func TestRegister_error(t *testing.T) {
 	if err == nil {
 		t.Error("want error")
 	}
+
+	var buf strings.Builder
+	buf.WriteString("SELECT zorder(0")
+	for i := 1; i < 80; i++ {
+		buf.WriteByte(',')
+		buf.WriteString(strconv.Itoa(0))
+	}
+	buf.WriteByte(')')
+	err = db.QueryRow(buf.String()).Scan(&got)
+	if err == nil {
+		t.Error("want error")
+	}
 }

go.mod

@@ -2,18 +2,18 @@ module github.com/ncruces/go-sqlite3
 
 go 1.21
 
-toolchain go1.22.5
+toolchain go1.23.0
 
 require (
 	github.com/dchest/siphash v1.2.3
 	github.com/ncruces/julianday v1.0.0
 	github.com/ncruces/sort v0.1.2
 	github.com/psanford/httpreadat v0.1.0
-	github.com/tetratelabs/wazero v1.7.3
-	golang.org/x/crypto v0.25.0
-	golang.org/x/sync v0.7.0
-	golang.org/x/sys v0.22.0
-	golang.org/x/text v0.16.0
+	github.com/tetratelabs/wazero v1.8.0
+	golang.org/x/crypto v0.26.0
+	golang.org/x/sync v0.8.0
+	golang.org/x/sys v0.24.0
+	golang.org/x/text v0.17.0
 	lukechampine.com/adiantum v1.1.1
 )
 

go.sum

@@ -8,15 +8,15 @@ github.com/ncruces/sort v0.1.2 h1:zKQ9CA4fpHPF6xsUhRTfi5EEryspuBpe/QA4VWQOV1U=
 github.com/ncruces/sort v0.1.2/go.mod h1:vEJUTBJtebIuCMmXD18GKo5GJGhsay+xZFOoBEIXFmE=
 github.com/psanford/httpreadat v0.1.0 h1:VleW1HS2zO7/4c7c7zNl33fO6oYACSagjJIyMIwZLUE=
 github.com/psanford/httpreadat v0.1.0/go.mod h1:Zg7P+TlBm3bYbyHTKv/EdtSJZn3qwbPwpfZ/I9GKCRE=
-github.com/tetratelabs/wazero v1.7.3 h1:PBH5KVahrt3S2AHgEjKu4u+LlDbbk+nsGE3KLucy6Rw=
-github.com/tetratelabs/wazero v1.7.3/go.mod h1:ytl6Zuh20R/eROuyDaGPkp82O9C/DJfXAwJfQ3X6/7Y=
-golang.org/x/crypto v0.25.0 h1:ypSNr+bnYL2YhwoMt2zPxHFmbAN1KZs/njMG3hxUp30=
-golang.org/x/crypto v0.25.0/go.mod h1:T+wALwcMOSE0kXgUAnPAHqTLW+XHgcELELW8VaDgm/M=
-golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
-golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
-golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
-golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
+github.com/tetratelabs/wazero v1.8.0 h1:iEKu0d4c2Pd+QSRieYbnQC9yiFlMS9D+Jr0LsRmcF4g=
+github.com/tetratelabs/wazero v1.8.0/go.mod h1:yAI0XTsMBhREkM/YDAK/zNou3GoiAce1P6+rp/wQhjs=
+golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw=
+golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54=
+golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
+golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.24.0 h1:Twjiwq9dn6R1fQcyiK+wQyHWfaz/BJB+YIpzU/Cv3Xg=
+golang.org/x/sys v0.24.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc=
+golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
 lukechampine.com/adiantum v1.1.1 h1:4fp6gTxWCqpEbLy40ExiYDDED3oUNWx5cTqBCtPdZqA=
 lukechampine.com/adiantum v1.1.1/go.mod h1:LrAYVnTYLnUtE/yMp5bQr0HstAf060YUF8nM0B6+rUw=

go.work.sum

@@ -3,5 +3,7 @@ golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
 golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
 golang.org/x/term v0.21.0/go.mod h1:ooXLefLobQVslOqselCNF4SxFAaoS6KujMbsGzSDmX0=
+golang.org/x/term v0.22.0/go.mod h1:F3qCibpT5AMpCRfhfT53vVJwhLtIVHhB9XDjfFvnMI4=
+golang.org/x/term v0.23.0/go.mod h1:DgV24QBUrK6jhZXl+20l6UWznPlwAHm1Q1mGHtydmSk=
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=

gormlite/go.mod

@@ -2,17 +2,18 @@ module github.com/ncruces/go-sqlite3/gormlite
 
 go 1.21
 
-toolchain go1.22.5
+toolchain go1.23.0
 
 require (
-	github.com/ncruces/go-sqlite3 v0.16.3
-	gorm.io/gorm v1.25.10
+	github.com/ncruces/go-sqlite3 v0.17.1
+	gorm.io/gorm v1.25.11
 )
 
 require (
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/ncruces/julianday v1.0.0 // indirect
-	github.com/tetratelabs/wazero v1.7.3 // indirect
-	golang.org/x/sys v0.22.0 // indirect
+	github.com/tetratelabs/wazero v1.8.0 // indirect
+	golang.org/x/sys v0.24.0 // indirect
+	golang.org/x/text v0.17.0 // indirect
 )

gormlite/go.sum

@@ -2,15 +2,15 @@ github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
 github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
-github.com/ncruces/go-sqlite3 v0.16.3 h1:Ky0denOdmAGOoCE6lQlw6GCJNMD8gTikNWe8rpu+Gjc=
-github.com/ncruces/go-sqlite3 v0.16.3/go.mod h1:sAU/vQwBmZ2hq5BlW/KTzqRFizL43bv2JQoBLgXhcMI=
+github.com/ncruces/go-sqlite3 v0.17.1 h1:VxTjDpCn87FaFlKMaAYC1jP7ND0d4UNj+6G4IQDHbgI=
+github.com/ncruces/go-sqlite3 v0.17.1/go.mod h1:FnCyui8SlDoL0mQZ5dTouNo7s7jXS0kJv9lBt1GlM9w=
 github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M=
 github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
-github.com/tetratelabs/wazero v1.7.3 h1:PBH5KVahrt3S2AHgEjKu4u+LlDbbk+nsGE3KLucy6Rw=
-github.com/tetratelabs/wazero v1.7.3/go.mod h1:ytl6Zuh20R/eROuyDaGPkp82O9C/DJfXAwJfQ3X6/7Y=
-golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
-golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
-golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
-gorm.io/gorm v1.25.10 h1:dQpO+33KalOA+aFYGlK+EfxcI5MbO7EP2yYygwh9h+s=
-gorm.io/gorm v1.25.10/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
+github.com/tetratelabs/wazero v1.8.0 h1:iEKu0d4c2Pd+QSRieYbnQC9yiFlMS9D+Jr0LsRmcF4g=
+github.com/tetratelabs/wazero v1.8.0/go.mod h1:yAI0XTsMBhREkM/YDAK/zNou3GoiAce1P6+rp/wQhjs=
+golang.org/x/sys v0.24.0 h1:Twjiwq9dn6R1fQcyiK+wQyHWfaz/BJB+YIpzU/Cv3Xg=
+golang.org/x/sys v0.24.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc=
+golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+gorm.io/gorm v1.25.11 h1:/Wfyg1B/je1hnDx3sMkX+gAlxrlZpn6X0BXRlwXlvHg=
+gorm.io/gorm v1.25.11/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ=

gormlite/sqlite.go

@@ -2,7 +2,6 @@
 package gormlite
 
 import (
-	"database/sql"
 	"strconv"
 
 	"gorm.io/gorm"
@@ -21,7 +20,7 @@ func Open(dsn string) gorm.Dialector {
 }
 
 // Open opens a GORM dialector from a database handle.
-func OpenDB(db *sql.DB) gorm.Dialector {
+func OpenDB(db gorm.ConnPool) gorm.Dialector {
 	return &_Dialector{Conn: db}
 }
 
@@ -38,7 +37,7 @@ func (dialector _Dialector) Initialize(db *gorm.DB) (err error) {
 	if dialector.Conn != nil {
 		db.ConnPool = dialector.Conn
 	} else {
-		conn, err := driver.Open(dialector.DSN, nil)
+		conn, err := driver.Open(dialector.DSN)
 		if err != nil {
 			return err
 		}

gormlite/sqlite_test.go

@@ -10,14 +10,14 @@ import (
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
 func TestDialector(t *testing.T) {
-	// This is the DSN of the in-memory SQLite database for these tests.
-	const InMemoryDSN = "file:testdatabase?mode=memory&cache=shared"
+	tmp := memdb.TestDB(t)
 
 	// Custom connection with a custom function called "my_custom_function".
-	db, err := driver.Open(InMemoryDSN, func(conn *sqlite3.Conn) error {
+	db, err := driver.Open(tmp, func(conn *sqlite3.Conn) error {
 		return conn.CreateFunction("my_custom_function", 0, sqlite3.DETERMINISTIC,
 			func(ctx sqlite3.Context, arg ...sqlite3.Value) {
 				ctx.ResultText("my-result")
@@ -36,14 +36,14 @@ func TestDialector(t *testing.T) {
 	}{
 		{
 			description:  "Default driver",
-			dialector:    Open(InMemoryDSN),
+			dialector:    Open(tmp),
 			openSuccess:  true,
 			query:        "SELECT 1",
 			querySuccess: true,
 		},
 		{
 			description:  "Custom function",
-			dialector:    Open(InMemoryDSN),
+			dialector:    Open(tmp),
 			openSuccess:  true,
 			query:        "SELECT my_custom_function()",
 			querySuccess: false,

gormlite/test.sh

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

internal/alloc/alloc_test.go

@@ -0,0 +1,14 @@
+package alloc_test
+
+import (
+	"math"
+	"testing"
+
+	"github.com/ncruces/go-sqlite3/internal/alloc"
+)
+
+func TestVirtual(t *testing.T) {
+	defer func() { _ = recover() }()
+	alloc.Virtual(math.MaxInt+2, math.MaxInt+2)
+	t.Error("want panic")
+}

internal/testcfg/testcfg.go

@@ -9,6 +9,8 @@ import (
 	"github.com/tetratelabs/wazero"
 )
 
+// notest
+
 func init() {
 	if bits.UintSize < 64 {
 		return

internal/util/error_test.go

@@ -0,0 +1,13 @@
+package util
+
+import "testing"
+
+func TestErrorJoiner(t *testing.T) {
+	var errs ErrorJoiner
+	errs.Join(NilErr, OOMErr)
+	for i, e := range []error{NilErr, OOMErr} {
+		if e != errs[i] {
+			t.Fail()
+		}
+	}
+}

internal/util/mmap.go

@@ -32,7 +32,7 @@ func (s *mmapState) new(ctx context.Context, mod api.Module, size int32) *Mapped
 
 	// Allocate page aligned memmory.
 	alloc := mod.ExportedFunction("aligned_alloc")
-	stack := [2]uint64{
+	stack := [...]uint64{
 		uint64(unix.Getpagesize()),
 		uint64(size),
 	}

json_test.go

@@ -0,0 +1,111 @@
+package sqlite3_test
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/ncruces/go-sqlite3"
+	_ "github.com/ncruces/go-sqlite3/embed"
+)
+
+func Example_json() {
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Exec(`
+		CREATE TABLE orders (
+			cart_id INTEGER PRIMARY KEY,
+			user_id INTEGER NOT NULL,
+			cart    BLOB -- stored as JSONB
+		) STRICT;
+	`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	type CartItem struct {
+		ItemID   string `json:"id"`
+		Name     string `json:"name"`
+		Quantity int    `json:"quantity,omitempty"`
+		Price    int    `json:"price,omitempty"`
+	}
+
+	type Cart struct {
+		Items []CartItem `json:"items"`
+	}
+
+	// convert to JSONB on insertion
+	stmt, _, err := db.Prepare(`INSERT INTO orders (user_id, cart) VALUES (?, jsonb(?))`)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer stmt.Close()
+
+	if err := stmt.BindInt(1, 123); err != nil {
+		log.Fatal(err)
+	}
+
+	if err := stmt.BindJSON(2, Cart{
+		[]CartItem{
+			{ItemID: "111", Name: "T-shirt", Quantity: 1, Price: 250},
+			{ItemID: "222", Name: "Trousers", Quantity: 1, Price: 600},
+		},
+	}); err != nil {
+		log.Fatal(err)
+	}
+
+	if err := stmt.Exec(); err != nil {
+		log.Fatal(err)
+	}
+
+	sl1, _, err := db.Prepare(`
+		SELECT total(json_each.value -> 'price')
+		FROM orders, json_each(cart -> 'items')
+		WHERE cart_id = last_insert_rowid()
+	`)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer sl1.Close()
+
+	for sl1.Step() {
+		fmt.Println("total:", sl1.ColumnInt(0))
+	}
+
+	if err := sl1.Err(); err != nil {
+		log.Fatal(err)
+	}
+
+	sl2, _, err := db.Prepare(`
+		SELECT json(cart) -- convert to JSON on retrieval
+		FROM orders
+		WHERE cart_id = last_insert_rowid()
+	`)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer sl2.Close()
+
+	for sl2.Step() {
+		var cart Cart
+		if err := sl2.ColumnJSON(0, &cart); err != nil {
+			log.Fatal(err)
+		}
+		for _, item := range cart.Items {
+			fmt.Printf("id: %s, name: %s, quantity: %d, price: %d\n",
+				item.ItemID, item.Name, item.Quantity, item.Price)
+		}
+	}
+
+	if err := sl2.Err(); err != nil {
+		log.Fatal(err)
+	}
+
+	// Output:
+	// total: 850
+	// id: 111, name: T-shirt, quantity: 1, price: 250
+	// id: 222, name: Trousers, quantity: 1, price: 600
+}

sqlite.go

@@ -13,6 +13,7 @@ import (
 	"github.com/ncruces/go-sqlite3/vfs"
 	"github.com/tetratelabs/wazero"
 	"github.com/tetratelabs/wazero/api"
+	"github.com/tetratelabs/wazero/experimental"
 )
 
 // Configure SQLite Wasm.
@@ -44,12 +45,14 @@ var instance struct {
 }
 
 func compileSQLite() {
-	if RuntimeConfig == nil {
-		RuntimeConfig = wazero.NewRuntimeConfig()
+	ctx := context.Background()
+	cfg := RuntimeConfig
+	if cfg == nil {
+		cfg = wazero.NewRuntimeConfig()
 	}
 
-	ctx := context.Background()
-	instance.runtime = wazero.NewRuntimeWithConfig(ctx, RuntimeConfig)
+	instance.runtime = wazero.NewRuntimeWithConfig(ctx,
+		cfg.WithCoreFeatures(api.CoreFeaturesV2|experimental.CoreFeaturesThreads))
 
 	env := instance.runtime.NewHostModuleBuilder("env")
 	env = vfs.ExportHostFunctions(env)
@@ -82,7 +85,7 @@ type sqlite struct {
 		id   [32]*byte
 		mask uint32
 	}
-	stack [8]uint64
+	stack [9]uint64
 	freer uint32
 }
 
@@ -303,6 +306,7 @@ func exportCallbacks(env wazero.HostModuleBuilder) wazero.HostModuleBuilder {
 	util.ExportFuncVI(env, "go_rollback_hook", rollbackCallback)
 	util.ExportFuncVIIIIJ(env, "go_update_hook", updateCallback)
 	util.ExportFuncIIIII(env, "go_wal_hook", walCallback)
+	util.ExportFuncIIIII(env, "go_trace", traceCallback)
 	util.ExportFuncIIIIII(env, "go_autovacuum_pages", autoVacuumCallback)
 	util.ExportFuncIIIIIII(env, "go_authorizer", authorizerCallback)
 	util.ExportFuncVIII(env, "go_log", logCallback)

sqlite3/column.c

@@ -48,4 +48,4 @@ static_assert(offsetof(union sqlite3_data, i) == 0, "Unexpected offset");
 static_assert(offsetof(union sqlite3_data, d) == 0, "Unexpected offset");
 static_assert(offsetof(union sqlite3_data, ptr) == 0, "Unexpected offset");
 static_assert(offsetof(union sqlite3_data, len) == 4, "Unexpected offset");
-static_assert(sizeof(union sqlite3_data) == 8, "Unexpected size");
+static_assert(sizeof(union sqlite3_data) == 8, "Unexpected size");

sqlite3/download.sh

@@ -3,7 +3,7 @@ set -euo pipefail
 
 cd -P -- "$(dirname -- "$0")"
 
-curl -#OL "https://sqlite.org/2024/sqlite-amalgamation-3460000.zip"
+curl -#OL "https://sqlite.org/2024/sqlite-amalgamation-3460100.zip"
 unzip -d . sqlite-amalgamation-*.zip
 mv sqlite-amalgamation-*/sqlite3* .
 rm -rf sqlite-amalgamation-*
@@ -12,24 +12,24 @@ cat *.patch | patch --no-backup-if-mismatch
 
 mkdir -p ext/
 cd ext/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/ext/misc/anycollseq.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/ext/misc/base64.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/ext/misc/decimal.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/ext/misc/ieee754.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/ext/misc/regexp.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/ext/misc/series.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/ext/misc/uint.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/anycollseq.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/base64.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/decimal.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/ieee754.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/regexp.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/series.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/uint.c"
 cd ~-
 
 cd ../vfs/tests/mptest/testdata/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/mptest/mptest.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/mptest/config01.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/mptest/config02.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/mptest/crash01.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/mptest/crash02.subtest"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/mptest/multiwrite01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/mptest/mptest.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/mptest/config01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/mptest/config02.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/mptest/crash01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/mptest/crash02.subtest"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/mptest/multiwrite01.test"
 cd ~-
 
 cd ../vfs/tests/speedtest1/testdata/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/test/speedtest1.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/test/speedtest1.c"
 cd ~-

sqlite3/hooks.c

@@ -10,7 +10,7 @@ int go_commit_hook(void *);
 void go_rollback_hook(void *);
 void go_update_hook(void *, int, char const *, char const *, sqlite3_int64);
 int go_wal_hook(void *, sqlite3 *, const char *, int);
-
+int go_trace(unsigned, void *, void *, void *);
 int go_authorizer(void *, int, const char *, const char *, const char *,
                   const char *);
 
@@ -47,6 +47,10 @@ int sqlite3_set_authorizer_go(sqlite3 *db, bool enable) {
   return sqlite3_set_authorizer(db, enable ? go_authorizer : NULL, /*arg=*/db);
 }
 
+int sqlite3_trace_go(sqlite3 *db, unsigned mask) {
+  return sqlite3_trace_v2(db, mask, go_trace, /*arg=*/db);
+}
+
 int sqlite3_config_log_go(bool enable) {
   return sqlite3_config(SQLITE_CONFIG_LOG, enable ? go_log : NULL,
                         /*arg=*/NULL);

stmt.go

@@ -15,6 +15,7 @@ import (
 type Stmt struct {
 	c      *Conn
 	err    error
+	sql    string
 	handle uint32
 }
 
@@ -29,6 +30,15 @@ func (s *Stmt) Close() error {
 	}
 
 	r := s.c.call("sqlite3_finalize", uint64(s.handle))
+	for i := range s.c.stmts {
+		if s == s.c.stmts[i] {
+			l := len(s.c.stmts) - 1
+			s.c.stmts[i] = s.c.stmts[l]
+			s.c.stmts[l] = nil
+			s.c.stmts = s.c.stmts[:l]
+			break
+		}
+	}
 
 	s.handle = 0
 	return s.c.error(r)
@@ -41,6 +51,24 @@ func (s *Stmt) Conn() *Conn {
 	return s.c
 }
 
+// SQL returns the SQL text used to create the prepared statement.
+//
+// https://sqlite.org/c3ref/expanded_sql.html
+func (s *Stmt) SQL() string {
+	return s.sql
+}
+
+// ExpandedSQL returns the SQL text of the prepared statement
+// with bound parameters expanded.
+//
+// https://sqlite.org/c3ref/expanded_sql.html
+func (s *Stmt) ExpandedSQL() string {
+	r := s.c.call("sqlite3_expanded_sql", uint64(s.handle))
+	sql := util.ReadString(s.c.mod, uint32(r), _MAX_SQL_LENGTH)
+	s.c.free(uint32(r))
+	return sql
+}
+
 // ReadOnly returns true if and only if the statement
 // makes no direct changes to the content of the database file.
 //
@@ -283,7 +311,8 @@ func (s *Stmt) BindNull(param int) error {
 //
 // https://sqlite.org/c3ref/bind_blob.html
 func (s *Stmt) BindTime(param int, value time.Time, format TimeFormat) error {
-	if format == TimeFormatDefault {
+	switch format {
+	case TimeFormatDefault, TimeFormatAuto, time.RFC3339Nano:
 		return s.bindRFC3339Nano(param, value)
 	}
 	switch v := format.Encode(value).(type) {

tests/bradfitz/sql_test.go

@@ -1,4 +1,4 @@
-//go:build (linux || darwin || windows || freebsd || illumos) && !sqlite3_nosys
+//go:build (linux || darwin || windows || freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock) && !sqlite3_nosys
 
 package bradfitz
 
@@ -45,7 +45,7 @@ func (t params) mustExec(sql string, args ...interface{}) sql.Result {
 
 func (sqliteDB) RunTest(t *testing.T, fn func(params)) {
 	db, err := sql.Open("sqlite3", "file:"+
-		filepath.Join(t.TempDir(), "foo.db")+
+		filepath.ToSlash(filepath.Join(t.TempDir(), "foo.db"))+
 		"?_pragma=busy_timeout(10000)&_pragma=synchronous(off)")
 	if err != nil {
 		t.Fatalf("foo.db open fail: %v", err)

tests/conn_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"math"
+	"net/url"
 	"os"
 	"path/filepath"
 	"strings"
@@ -12,6 +13,8 @@ import (
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+	"github.com/ncruces/go-sqlite3/vfs"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 	_ "github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
@@ -172,6 +175,11 @@ func TestConn_SetInterrupt(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+
+	db.SetInterrupt(ctx)
+	if got := db.GetInterrupt(); got != ctx {
+		t.Errorf("got %v, want %v", got, ctx)
+	}
 }
 
 func TestConn_Prepare_empty(t *testing.T) {
@@ -332,6 +340,147 @@ func TestConn_ConfigLog(t *testing.T) {
 	}
 }
 
+func TestConn_FileControl(t *testing.T) {
+	t.Parallel()
+
+	file := filepath.Join(t.TempDir(), "test.db")
+	db, err := sqlite3.Open(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	t.Run("MISUSE", func(t *testing.T) {
+		_, err := db.FileControl("main", 0)
+		if !errors.Is(err, sqlite3.MISUSE) {
+			t.Errorf("got %v, want MISUSE", err)
+		}
+	})
+	t.Run("FCNTL_RESET_CACHE", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_RESET_CACHE)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != nil {
+			t.Errorf("got %v, want nil", o)
+		}
+	})
+
+	t.Run("FCNTL_PERSIST_WAL", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_PERSIST_WAL)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != false {
+			t.Errorf("got %v, want false", o)
+		}
+
+		o, err = db.FileControl("", sqlite3.FCNTL_PERSIST_WAL, true)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != true {
+			t.Errorf("got %v, want true", o)
+		}
+
+		o, err = db.FileControl("", sqlite3.FCNTL_PERSIST_WAL)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != true {
+			t.Errorf("got %v, want true", o)
+		}
+	})
+
+	t.Run("FCNTL_CHUNK_SIZE", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_CHUNK_SIZE, 1024*1024)
+		if !errors.Is(err, sqlite3.NOTFOUND) {
+			t.Errorf("got %v, want NOTFOUND", err)
+		}
+		if o != nil {
+			t.Errorf("got %v, want nil", o)
+		}
+	})
+
+	t.Run("FCNTL_RESERVE_BYTES", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_RESERVE_BYTES, 4)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != 0 {
+			t.Errorf("got %v, want 0", o)
+		}
+
+		o, err = db.FileControl("", sqlite3.FCNTL_RESERVE_BYTES)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != 4 {
+			t.Errorf("got %v, want 4", o)
+		}
+	})
+
+	t.Run("FCNTL_DATA_VERSION", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_DATA_VERSION)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != uint32(2) {
+			t.Errorf("got %v, want 2", o)
+		}
+	})
+
+	t.Run("FCNTL_VFS_POINTER", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_VFS_POINTER)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != vfs.Find("os") {
+			t.Errorf("got %v, want os", o)
+		}
+	})
+
+	t.Run("FCNTL_FILE_POINTER", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_FILE_POINTER)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, ok := o.(vfs.File); !ok {
+			t.Errorf("got %v, want File", o)
+		}
+	})
+
+	t.Run("FCNTL_JOURNAL_POINTER", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_JOURNAL_POINTER)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != nil {
+			t.Errorf("got %v, want nil", o)
+		}
+	})
+
+	t.Run("FCNTL_LOCKSTATE", func(t *testing.T) {
+		if !vfs.SupportsFileLocking {
+			t.Skip("skipping without locks")
+		}
+
+		txn, err := db.BeginExclusive()
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer txn.End(&err)
+
+		o, err := db.FileControl("", sqlite3.FCNTL_LOCKSTATE)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != vfs.LOCK_EXCLUSIVE {
+			t.Errorf("got %v, want LOCK_EXCLUSIVE", o)
+		}
+	})
+}
+
 func TestConn_Limit(t *testing.T) {
 	t.Parallel()
 
@@ -372,18 +521,102 @@ func TestConn_SetAuthorizer(t *testing.T) {
 	defer db.Close()
 
 	err = db.SetAuthorizer(func(action sqlite3.AuthorizerActionCode, name3rd, name4th, schema, nameInner string) sqlite3.AuthorizerReturnCode {
+		if action != sqlite3.AUTH_PRAGMA {
+			t.Errorf("got %v, want PRAGMA", action)
+		}
+		if name3rd != "busy_timeout" {
+			t.Errorf("got %q, want busy_timeout", name3rd)
+		}
+		if name4th != "5000" {
+			t.Errorf("got %q, want 5000", name4th)
+		}
+		if schema != "main" {
+			t.Errorf("got %q, want main", schema)
+		}
 		return sqlite3.AUTH_DENY
 	})
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	err = db.Exec(`SELECT * FROM sqlite_schema`)
+	err = db.Exec(`PRAGMA main.busy_timeout=5000`)
 	if !errors.Is(err, sqlite3.AUTH) {
 		t.Errorf("got %v, want sqlite3.AUTH", err)
 	}
 }
 
+func TestConn_Trace(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	rows := 0
+	closed := false
+	err = db.Trace(math.MaxUint32, func(evt sqlite3.TraceEvent, a1 any, a2 any) error {
+		switch evt {
+		case sqlite3.TRACE_CLOSE:
+			closed = true
+			_ = a1.(*sqlite3.Conn)
+			return db.Exec(`PRAGMA optimize`)
+		case sqlite3.TRACE_STMT:
+			stmt := a1.(*sqlite3.Stmt)
+			if sql := a2.(string); sql != stmt.SQL() {
+				t.Errorf("got %q, want %q", sql, stmt.SQL())
+			}
+			if sql := stmt.ExpandedSQL(); sql != `SELECT 1` {
+				t.Errorf("got %q", sql)
+			}
+		case sqlite3.TRACE_PROFILE:
+			_ = a1.(*sqlite3.Stmt)
+			if ns := a2.(int64); ns < 0 {
+				t.Errorf("got %d", ns)
+			}
+		case sqlite3.TRACE_ROW:
+			_ = a1.(*sqlite3.Stmt)
+			if a2 != nil {
+				t.Errorf("got %v", a2)
+			}
+			rows++
+		}
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT ?`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = stmt.BindInt(1, 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = stmt.Exec()
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = stmt.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rows != 1 {
+		t.Error("want 1")
+	}
+
+	err = db.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !closed {
+		t.Error("want closed")
+	}
+}
+
 func TestConn_ReleaseMemory(t *testing.T) {
 	t.Parallel()
 
@@ -496,8 +729,11 @@ func TestConn_DBName(t *testing.T) {
 
 func TestConn_AutoVacuumPages(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t, url.Values{
+		"_pragma": {"auto_vacuum(full)"},
+	})
 
-	db, err := sqlite3.Open("file:test.db?vfs=memdb&_pragma=auto_vacuum(full)")
+	db, err := sqlite3.Open(tmp)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -525,3 +761,96 @@ func TestConn_AutoVacuumPages(t *testing.T) {
 		t.Fatal(err)
 	}
 }
+
+func TestConn_Status(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Exec(`CREATE TABLE test (col)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	cr, hi, err := db.Status(sqlite3.DBSTATUS_SCHEMA_USED, true)
+	if err != nil {
+		t.Error("want nil")
+	}
+	if cr == 0 {
+		t.Error("want something")
+	}
+	if hi != 0 {
+		t.Error("want zero")
+	}
+
+	cr, hi, err = db.Status(sqlite3.DBSTATUS_LOOKASIDE_HIT, true)
+	if err != nil {
+		t.Error("want nil")
+	}
+	if cr != 0 {
+		t.Error("want zero")
+	}
+	if hi == 0 {
+		t.Error("want something")
+	}
+
+	cr, hi, err = db.Status(sqlite3.DBSTATUS_LOOKASIDE_HIT, true)
+	if err != nil {
+		t.Error("want nil")
+	}
+	if cr != 0 {
+		t.Error("want zero")
+	}
+	if hi != 0 {
+		t.Error("want zero")
+	}
+}
+
+func TestConn_TableColumnMetadata(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Exec(`CREATE TABLE test (col)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, _, _, _, _, err = db.TableColumnMetadata("", "table", "")
+	if err == nil {
+		t.Error("want error")
+	}
+
+	_, _, _, _, _, err = db.TableColumnMetadata("", "test", "")
+	if err != nil {
+		t.Error("want nil")
+	}
+
+	typ, ord, nn, pk, ai, err := db.TableColumnMetadata("main", "test", "rowid")
+	if err != nil {
+		t.Error("want nil")
+	}
+	if typ != "INTEGER" {
+		t.Error("want INTEGER")
+	}
+	if ord != "BINARY" {
+		t.Error("want BINARY")
+	}
+	if nn != false {
+		t.Error("want false")
+	}
+	if pk != true {
+		t.Error("want true")
+	}
+	if ai != false {
+		t.Error("want false")
+	}
+}

tests/db_test.go

@@ -12,6 +12,7 @@ import (
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 	"github.com/ncruces/go-sqlite3/vfs"
 	_ "github.com/ncruces/go-sqlite3/vfs/adiantum"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 	_ "github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
@@ -65,7 +66,7 @@ func TestDB_utf16(t *testing.T) {
 
 func TestDB_memdb(t *testing.T) {
 	t.Parallel()
-	testDB(t, "file:test.db?vfs=memdb")
+	testDB(t, memdb.TestDB(t))
 }
 
 func TestDB_adiantum(t *testing.T) {

tests/driver_test.go

@@ -4,18 +4,23 @@ import (
 	"context"
 	"testing"
 
+	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
 func TestDriver(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	db, err := driver.Open(":memory:", nil)
+	db, err := driver.Open(tmp, nil, func(c *sqlite3.Conn) error {
+		return c.Exec(`PRAGMA optimize`)
+	})
 	if err != nil {
 		t.Fatal(err)
 	}

tests/func_test.go

@@ -48,6 +48,9 @@ func TestCreateFunction(t *testing.T) {
 		case 10:
 			ctx.ResultNull()
 		case 11:
+			if arg.NoChange() || arg.FromBind() {
+				t.Error()
+			}
 			ctx.ResultError(sqlite3.FULL)
 		}
 	})
@@ -168,6 +171,44 @@ func TestCreateFunction(t *testing.T) {
 	}
 }
 
+func TestCreateFunction_error(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	var want error
+	err = db.CreateFunction("test", 0, sqlite3.INNOCUOUS, func(ctx sqlite3.Context, _ ...sqlite3.Value) {
+		ctx.ResultError(want)
+	})
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT test()`)
+	if err != nil {
+		t.Error(err)
+	}
+	defer func() { recover() }()
+	defer stmt.Close()
+
+	for _, want = range []error{sqlite3.FULL, sqlite3.TOOBIG} {
+		if stmt.Step() {
+			t.Error("want error")
+		}
+		if got := stmt.Err(); !errors.Is(got, want) {
+			t.Errorf("got %v, want %v", got, want)
+		}
+	}
+
+	want = sqlite3.NOMEM
+	stmt.Step()
+}
+
 func TestOverloadFunction(t *testing.T) {
 	t.Parallel()
 
@@ -240,3 +281,41 @@ func TestAnyCollationNeeded(t *testing.T) {
 		t.Fatal(err)
 	}
 }
+
+func TestPointer(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	var want any = "xpto"
+
+	err = db.CreateFunction("ident", 1, 0, func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+		got := arg[0].Pointer()
+		if got != want {
+			t.Errorf("want %v, got %v", want, got)
+		}
+		ctx.ResultPointer(got)
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT ident(ident(?))`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = stmt.BindPointer(1, want)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = stmt.Exec()
+	if err != nil {
+		t.Error(err)
+	}
+}

tests/json_test.go

@@ -11,16 +11,18 @@ import (
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 	"github.com/ncruces/julianday"
 )
 
 func TestJSON(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	db, err := driver.Open(":memory:", nil)
+	db, err := driver.Open(tmp)
 	if err != nil {
 		t.Fatal(err)
 	}

tests/parallel/parallel_test.go

@@ -2,6 +2,7 @@ package tests
 
 import (
 	"io"
+	"net/url"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -31,7 +32,7 @@ func Test_parallel(t *testing.T) {
 	}
 
 	name := "file:" +
-		filepath.Join(t.TempDir(), "test.db") +
+		filepath.ToSlash(filepath.Join(t.TempDir(), "test.db")) +
 		"?_pragma=busy_timeout(10000)" +
 		"&_pragma=journal_mode(truncate)" +
 		"&_pragma=synchronous(off)"
@@ -45,7 +46,7 @@ func Test_wal(t *testing.T) {
 	}
 
 	name := "file:" +
-		filepath.Join(t.TempDir(), "test.db") +
+		filepath.ToSlash(filepath.Join(t.TempDir(), "test.db")) +
 		"?_pragma=busy_timeout(10000)" +
 		"&_pragma=journal_mode(wal)" +
 		"&_pragma=synchronous(off)"
@@ -61,8 +62,9 @@ func Test_memdb(t *testing.T) {
 		iter = 5000
 	}
 
-	memdb.Create("test.db", nil)
-	name := "file:/test.db?vfs=memdb"
+	name := memdb.TestDB(t, url.Values{
+		"_pragma": {"busy_timeout(10000)"},
+	})
 	testParallel(t, name, iter)
 	testIntegrity(t, name)
 }
@@ -82,7 +84,10 @@ func Test_adiantum(t *testing.T) {
 	name := "file:" +
 		filepath.ToSlash(filepath.Join(t.TempDir(), "test.db")) +
 		"?vfs=adiantum" +
-		"&_pragma=hexkey(e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855)"
+		"&_pragma=hexkey(e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855)" +
+		"&_pragma=busy_timeout(10000)" +
+		"&_pragma=journal_mode(truncate)" +
+		"&_pragma=synchronous(off)"
 	testParallel(t, name, iter)
 	testIntegrity(t, name)
 }
@@ -98,7 +103,7 @@ func TestMultiProcess(t *testing.T) {
 	file := filepath.Join(t.TempDir(), "test.db")
 	t.Setenv("TestMultiProcess_dbfile", file)
 
-	name := "file:" + file +
+	name := "file:" + filepath.ToSlash(file) +
 		"?_pragma=busy_timeout(10000)" +
 		"&_pragma=journal_mode(truncate)" +
 		"&_pragma=synchronous(off)"
@@ -133,7 +138,7 @@ func TestChildProcess(t *testing.T) {
 		t.SkipNow()
 	}
 
-	name := "file:" + file +
+	name := "file:" + filepath.ToSlash(file) +
 		"?_pragma=busy_timeout(10000)" +
 		"&_pragma=journal_mode(truncate)" +
 		"&_pragma=synchronous(off)"
@@ -177,8 +182,9 @@ func Benchmark_memdb(b *testing.B) {
 	sqlite3.Initialize()
 	b.ResetTimer()
 
-	memdb.Create("test.db", nil)
-	name := "file:/test.db?vfs=memdb"
+	name := memdb.TestDB(b, url.Values{
+		"_pragma": {"busy_timeout(10000)"},
+	})
 	testParallel(b, name, b.N)
 }
 
@@ -218,11 +224,6 @@ func testParallel(t testing.TB, name string, n int) {
 		}
 		defer db.Close()
 
-		err = db.BusyTimeout(10 * time.Second)
-		if err != nil {
-			return err
-		}
-
 		stmt, _, err := db.Prepare(`SELECT id, name FROM users`)
 		if err != nil {
 			return err

tests/stmt_test.go

@@ -503,6 +503,13 @@ func TestStmt(t *testing.T) {
 		}
 	}
 
+	db.Stmts()(func(s *sqlite3.Stmt) bool {
+		if s != stmt {
+			t.Error()
+		}
+		return false
+	})
+
 	if err := stmt.Close(); err != nil {
 		t.Fatal(err)
 	}
@@ -611,10 +618,40 @@ func TestStmt_ColumnTime(t *testing.T) {
 			t.Errorf("want error")
 		}
 	}
+}
+
+func TestStmt_ColumnValue(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	stmt, _, err := db.Prepare(`SELECT 1`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer stmt.Close()
+
+	if stmt.Step() {
+		val := stmt.ColumnValue(0)
+		if _, err := val.InFirst(); err == nil {
+			t.Error("want error")
+		}
+		if _, err := val.InNext(); err == nil {
+			t.Error("want error")
+		}
+	}
 
 	if got := stmt.Status(sqlite3.STMTSTATUS_RUN, true); got != 1 {
 		t.Errorf("got %d, want 1", got)
 	}
+
+	if got := stmt.Status(math.MaxUint32, false); got != 0 {
+		t.Errorf("got %d, want 0", got)
+	}
 }
 
 func TestStmt_Error(t *testing.T) {

tests/time_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
 func TestTimeFormat_Encode(t *testing.T) {
@@ -132,11 +133,12 @@ func TestTimeFormat_Decode(t *testing.T) {
 
 func TestTimeFormat_Scanner(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	db, err := driver.Open(":memory:", nil)
+	db, err := driver.Open(tmp)
 	if err != nil {
 		t.Fatal(err)
 	}

tests/txn_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
-	_ "github.com/ncruces/go-sqlite3/vfs/memdb"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
 func TestConn_Transaction_exec(t *testing.T) {
@@ -184,6 +184,10 @@ func TestConn_Transaction_interrupt(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	err = db.CacheFlush()
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	cancel()
 	_, err = db.BeginImmediate()
@@ -250,14 +254,15 @@ func TestConn_Transaction_interrupted(t *testing.T) {
 
 func TestConn_Transaction_busy(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db1, err := sqlite3.Open("file:/test.db?vfs=memdb")
+	db1, err := sqlite3.Open(tmp)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db1.Close()
 
-	db2, err := sqlite3.Open("file:/test.db?vfs=memdb&_pragma=busy_timeout(10000)")
+	db2, err := sqlite3.Open(tmp + "&_pragma=busy_timeout(10000)")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -339,6 +344,21 @@ func TestConn_Transaction_rollback(t *testing.T) {
 	}
 }
 
+func TestConn_Transaction_concurrent(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	_, err = db.BeginConcurrent()
+	if !errors.Is(err, sqlite3.ERROR) {
+		t.Errorf("got %v, want sqlite3.ERROR", err)
+	}
+}
+
 func TestConn_Savepoint_exec(t *testing.T) {
 	t.Parallel()
 

tests/wal_test.go

@@ -54,13 +54,13 @@ func TestWAL_readonly(t *testing.T) {
 
 	tmp := filepath.ToSlash(filepath.Join(t.TempDir(), "test.db"))
 
-	db1, err := driver.Open("file:"+tmp+"?_pragma=journal_mode(wal)&_txlock=immediate", nil)
+	db1, err := driver.Open("file:" + tmp + "?_pragma=journal_mode(wal)&_txlock=immediate")
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db1.Close()
 
-	db2, err := driver.Open("file:"+tmp+"?_pragma=journal_mode(wal)&mode=ro", nil)
+	db2, err := driver.Open("file:" + tmp + "?_pragma=journal_mode(wal)&mode=ro")
 	if err != nil {
 		t.Fatal(err)
 	}

txn.go

@@ -32,6 +32,19 @@ func (c *Conn) Begin() Txn {
 	return Txn{c}
 }
 
+// BeginConcurrent starts a concurrent transaction.
+//
+// Experimental: requires a custom build of SQLite.
+//
+// https://sqlite.org/cgi/src/doc/begin-concurrent/doc/begin_concurrent.md
+func (c *Conn) BeginConcurrent() (Txn, error) {
+	err := c.Exec(`BEGIN CONCURRENT`)
+	if err != nil {
+		return Txn{}, err
+	}
+	return Txn{c}, nil
+}
+
 // BeginImmediate starts an immediate transaction.
 //
 // https://sqlite.org/lang_transaction.html
@@ -217,7 +230,7 @@ func (c *Conn) txnExecInterrupted(sql string) error {
 	return err
 }
 
-// TxnState starts a deferred transaction.
+// TxnState determines the transaction state of a database.
 //
 // https://sqlite.org/c3ref/txn_state.html
 func (c *Conn) TxnState(schema string) TxnState {
@@ -292,3 +305,11 @@ func updateCallback(ctx context.Context, mod api.Module, pDB uint32, action Auth
 		c.update(action, schema, table, int64(rowid))
 	}
 }
+
+// CacheFlush flushes caches to disk mid-transaction.
+//
+// https://sqlite.org/c3ref/db_cacheflush.html
+func (c *Conn) CacheFlush() error {
+	r := c.call("sqlite3_db_cacheflush", uint64(c.handle))
+	return c.error(r)
+}

util/vtabutil/parse.go

@@ -50,7 +50,8 @@ func Parse(sql string) (_ *Table, err error) {
 		copy(buf, sql)
 	}
 
-	r, err := mod.ExportedFunction("sql3parse_table").Call(ctx, sqlp, uint64(len(sql)), errp)
+	stack := [...]uint64{sqlp, uint64(len(sql)), errp}
+	err = mod.ExportedFunction("sql3parse_table").CallWithStack(ctx, stack[:])
 	if err != nil {
 		return nil, err
 	}
@@ -66,7 +67,7 @@ func Parse(sql string) (_ *Table, err error) {
 	}
 
 	var tab Table
-	tab.load(mod, uint32(r[0]), sql)
+	tab.load(mod, uint32(stack[0]), sql)
 	return &tab, nil
 }
 

util/vtabutil/parse/build.sh

@@ -4,10 +4,12 @@ set -euo pipefail
 cd -P -- "$(dirname -- "$0")"
 
 ROOT=../../../
-BINARYEN="$ROOT/tools/binaryen-version_117/bin"
-WASI_SDK="$ROOT/tools/wasi-sdk-22.0/bin"
+BINARYEN="$ROOT/tools/binaryen/bin"
+WASI_SDK="$ROOT/tools/wasi-sdk/bin"
 
-"$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -flto -g0 -Oz \
+trap 'rm -f sql3parse_table.tmp' EXIT
+
+"$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -g0 -Oz \
 	-Wall -Wextra -o sql3parse_table.wasm main.c \
 	-mexec-model=reactor \
 	-msimd128 -mmutable-globals -mmultivalue \
@@ -18,7 +20,6 @@ WASI_SDK="$ROOT/tools/wasi-sdk-22.0/bin"
 	-Wl,--import-undefined \
 	-Wl,--export=sql3parse_table
 
-trap 'rm -f sql3parse_table.tmp' EXIT
 "$BINARYEN/wasm-ctor-eval" -c _initialize sql3parse_table.wasm -o sql3parse_table.tmp
 "$BINARYEN/wasm-opt" --strip --strip-debug --strip-producers -c -Oz \
 	sql3parse_table.tmp -o sql3parse_table.wasm \

value.go

@@ -201,6 +201,14 @@ func (v Value) NoChange() bool {
 	return r != 0
 }
 
+// FromBind returns true if value originated from a bound parameter.
+//
+// https://sqlite.org/c3ref/value_blob.html
+func (v Value) FromBind() bool {
+	r := v.c.call("sqlite3_value_frombind", v.protected())
+	return r != 0
+}
+
 // InFirst returns the first element
 // on the right-hand side of an IN constraint.
 //

vfs/adiantum/adiantum_test.go

@@ -23,7 +23,7 @@ func Test_fileformat(t *testing.T) {
 	readervfs.Create("test.db", ioutil.NewSizeReaderAt(strings.NewReader(testDB)))
 	adiantum.Register("radiantum", vfs.Find("reader"), nil)
 
-	db, err := driver.Open("file:test.db?vfs=radiantum", nil)
+	db, err := driver.Open("file:test.db?vfs=radiantum")
 	if err != nil {
 		t.Fatal(err)
 	}

vfs/adiantum/example_test.go

@@ -1,4 +1,4 @@
-//go:build (linux || darwin || windows || freebsd || illumos) && !sqlite3_nosys
+//go:build (linux || darwin || windows || freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock) && !sqlite3_nosys
 
 package adiantum_test
 

vfs/adiantum/hbsh.go

@@ -17,6 +17,7 @@ type hbshVFS struct {
 }
 
 func (h *hbshVFS) Open(name string, flags vfs.OpenFlag) (vfs.File, vfs.OpenFlag, error) {
+	// notest // OpenFilename is called instead
 	return nil, 0, sqlite3.CANTOPEN
 }
 

vfs/const_test.go

@@ -0,0 +1,24 @@
+package vfs
+
+import (
+	"math"
+	"testing"
+)
+
+func Test_ErrorCode_Error(t *testing.T) {
+	tests := []struct {
+		code _ErrorCode
+		want string
+	}{
+		{_OK, "sqlite3: not an error"},
+		{_ERROR, "sqlite3: SQL logic error"},
+		{math.MaxUint32, "sqlite3: unknown error"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.want, func(t *testing.T) {
+			if got := tt.code.Error(); got != tt.want {
+				t.Errorf("_ErrorCode.Error() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

vfs/file.go

@@ -69,6 +69,7 @@ func (vfsOS) Access(name string, flags AccessFlag) (bool, error) {
 }
 
 func (vfsOS) Open(name string, flags OpenFlag) (File, OpenFlag, error) {
+	// notest // OpenFilename is called instead
 	return nil, 0, _CANTOPEN
 }
 

vfs/filename.go

@@ -20,8 +20,8 @@ type Filename struct {
 	stack [2]uint64
 }
 
-// OpenFilename is an internal API users should not call directly.
-func OpenFilename(ctx context.Context, mod api.Module, id uint32, flags OpenFlag) *Filename {
+// GetFilename is an internal API users should not call directly.
+func GetFilename(ctx context.Context, mod api.Module, id uint32, flags OpenFlag) *Filename {
 	if id == 0 {
 		return nil
 	}
@@ -66,6 +66,10 @@ func (n *Filename) path(method string) string {
 	if n == nil || n.zPath == 0 {
 		return ""
 	}
+	if n.flags&(OPEN_MAIN_DB|OPEN_MAIN_JOURNAL|OPEN_WAL) == 0 {
+		return ""
+	}
+
 	n.stack[0] = uint64(n.zPath)
 	fn := n.mod.ExportedFunction(method)
 	if err := fn.CallWithStack(n.ctx, n.stack[:]); err != nil {

vfs/memdb/api.go

@@ -10,7 +10,10 @@
 package memdb
 
 import (
+	"fmt"
+	"net/url"
 	"sync"
+	"testing"
 
 	"github.com/ncruces/go-sqlite3/vfs"
 )
@@ -39,8 +42,9 @@ func Create(name string, data []byte) {
 		size: int64(len(data)),
 	}
 
-	// Convert data from WAL to rollback journal.
-	if len(data) >= 20 && data[18] == 2 && data[19] == 2 {
+	// Convert data from WAL/2 to rollback journal.
+	if len(data) >= 20 && (data[18] == 2 && data[19] == 2 ||
+		data[18] == 3 && data[19] == 3) {
 		data[18] = 1
 		data[19] = 1
 	}
@@ -66,3 +70,30 @@ func Delete(name string) {
 	defer memoryMtx.Unlock()
 	delete(memoryDBs, name)
 }
+
+// TestDB creates an empty shared memory database for the test to use.
+// The database is automatically deleted when the test and all its subtests complete.
+// Each subsequent call to TestDB returns a unique database.
+func TestDB(tb testing.TB, params ...url.Values) string {
+	tb.Helper()
+
+	name := fmt.Sprintf("%s_%p", tb.Name(), tb)
+	tb.Cleanup(func() { Delete(name) })
+	Create(name, nil)
+
+	p := url.Values{"vfs": {"memdb"}}
+	for _, v := range params {
+		for k, v := range v {
+			for _, v := range v {
+				p.Add(k, v)
+			}
+		}
+	}
+
+	return (&url.URL{
+		Scheme:   "file",
+		OmitHost: true,
+		Path:     "/" + name,
+		RawQuery: p.Encode(),
+	}).String()
+}