Fix #255.

Bumps [golang.org/x/crypto](https://github.com/golang/crypto) from 0.35.0 to 0.36.0.
- [Commits](https://github.com/golang/crypto/compare/v0.35.0...v0.36.0)

---
updated-dependencies:
- dependency-name: golang.org/x/crypto
  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/repro.sh

@@ -3,13 +3,13 @@ set -euo pipefail
 
 if [[ "$OSTYPE" == "linux"* ]]; then
   WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-25/wasi-sdk-25.0-x86_64-linux.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_122/binaryen-version_122-x86_64-linux.tar.gz"
+  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_123/binaryen-version_123-x86_64-linux.tar.gz"
 elif [[ "$OSTYPE" == "darwin"* ]]; then
   WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-25/wasi-sdk-25.0-arm64-macos.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_122/binaryen-version_122-arm64-macos.tar.gz"
+  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_123/binaryen-version_123-arm64-macos.tar.gz"
 elif [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" ]]; then
   WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-25/wasi-sdk-25.0-x86_64-windows.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_122/binaryen-version_122-x86_64-windows.tar.gz"
+  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_123/binaryen-version_123-x86_64-windows.tar.gz"
 fi
 
 # Download tools

README.md

@@ -65,17 +65,20 @@ db.QueryRow(`SELECT sqlite_version()`).Scan(&version)
 This module replaces the SQLite [OS Interface](https://sqlite.org/vfs.html)
 (aka VFS) with a [pure Go](vfs/) implementation,
 which has advantages and disadvantages.
-
 Read more about the Go VFS design [here](vfs/README.md).
 
+Because each database connection executes within a Wasm sandboxed environment,
+memory usage will be higher than alternatives.
+
 ### Testing
 
 This project aims for [high test coverage](https://github.com/ncruces/go-sqlite3/wiki/Test-coverage-report).
 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.
+[wazero's](https://tetrate.io/blog/introducing-wazero-from-tetrate/#:~:text=Rock%2Dsolid%20test%20approach)
+thorough testing.
 
 Every commit is [tested](https://github.com/ncruces/go-sqlite3/wiki/Support-matrix) on
-Linux (amd64/arm64/386/riscv64/ppc64le/s390x), macOS (amd64/arm64),
+Linux (amd64/arm64/386/riscv64/ppc64le/s390x), macOS (arm64/amd64),
 Windows (amd64), FreeBSD (amd64/arm64), OpenBSD (amd64), NetBSD (amd64/arm64),
 DragonFly BSD (amd64), illumos (amd64), and Solaris (amd64).
 
@@ -84,12 +87,21 @@ The Go VFS is tested by running SQLite's
 
 ### Performance
 
-Perfomance of the [`database/sql`](https://pkg.go.dev/database/sql) driver is
+Performance of the [`database/sql`](https://pkg.go.dev/database/sql) driver is
 [competitive](https://github.com/cvilsmeier/go-sqlite-bench) with alternatives.
 
-The Wasm and VFS layers are also tested by running SQLite's
+The Wasm and VFS layers are also benchmarked by running SQLite's
 [speedtest1](https://github.com/sqlite/sqlite/blob/master/test/speedtest1.c).
 
+### Concurrency
+
+This module behaves similarly to SQLite in [multi-thread](https://sqlite.org/threadsafe.html) mode:
+it is goroutine-safe, provided that no single database connection, or object derived from it,
+is used concurrently by multiple goroutines.
+
+The [`database/sql`](https://pkg.go.dev/database/sql) API is safe to use concurrently,
+according to its documentation.
+
 ### FAQ, issues, new features
 
 For questions, please see [Discussions](https://github.com/ncruces/go-sqlite3/discussions/categories/q-a).
@@ -98,7 +110,7 @@ Also, post there if you used this driver for something interesting
 ([_"Show and tell"_](https://github.com/ncruces/go-sqlite3/discussions/categories/show-and-tell)),
 have an [idea](https://github.com/ncruces/go-sqlite3/discussions/categories/ideas)…
 
-The [Issue](https://github.com/ncruces/go-sqlite3/issues) tracker is for bugs we want fixed,
+The [Issue](https://github.com/ncruces/go-sqlite3/issues) tracker is for bugs,
 and features we're working on, planning to work on, or asking for help with.
 
 ### Alternatives
@@ -106,4 +118,4 @@ and features we're working on, planning to work on, or asking for help with.
 - [`modernc.org/sqlite`](https://pkg.go.dev/modernc.org/sqlite)
 - [`crawshaw.io/sqlite`](https://pkg.go.dev/crawshaw.io/sqlite)
 - [`github.com/mattn/go-sqlite3`](https://pkg.go.dev/github.com/mattn/go-sqlite3)
-- [`github.com/zombiezen/go-sqlite`](https://pkg.go.dev/github.com/zombiezen/go-sqlite)
+- [`github.com/zombiezen/go-sqlite`](https://pkg.go.dev/github.com/zombiezen/go-sqlite)

blob.go

@@ -31,6 +31,10 @@ var _ io.ReadWriteSeeker = &Blob{}
 //
 // https://sqlite.org/c3ref/blob_open.html
 func (c *Conn) OpenBlob(db, table, column string, row int64, write bool) (*Blob, error) {
+	if c.interrupt.Err() != nil {
+		return nil, INTERRUPT
+	}
+
 	defer c.arena.mark()()
 	blobPtr := c.arena.new(ptrlen)
 	dbPtr := c.arena.string(db)
@@ -42,7 +46,6 @@ func (c *Conn) OpenBlob(db, table, column string, row int64, write bool) (*Blob,
 		flags = 1
 	}
 
-	c.checkInterrupt(c.handle)
 	rc := res_t(c.call("sqlite3_blob_open", stk_t(c.handle),
 		stk_t(dbPtr), stk_t(tablePtr), stk_t(columnPtr),
 		stk_t(row), stk_t(flags), stk_t(blobPtr)))
@@ -253,7 +256,9 @@ func (b *Blob) Seek(offset int64, whence int) (int64, error) {
 //
 // https://sqlite.org/c3ref/blob_reopen.html
 func (b *Blob) Reopen(row int64) error {
-	b.c.checkInterrupt(b.c.handle)
+	if b.c.interrupt.Err() != nil {
+		return INTERRUPT
+	}
 	err := b.c.error(res_t(b.c.call("sqlite3_blob_reopen", stk_t(b.handle), stk_t(row))))
 	b.bytes = int64(int32(b.c.call("sqlite3_blob_bytes", stk_t(b.handle))))
 	b.offset = 0

config.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"strconv"
+	"sync/atomic"
 
 	"github.com/tetratelabs/wazero/api"
 
@@ -48,6 +49,15 @@ func (c *Conn) Config(op DBConfig, arg ...bool) (bool, error) {
 	return util.ReadBool(c.mod, argsPtr), c.error(rc)
 }
 
+var defaultLogger atomic.Pointer[func(code ExtendedErrorCode, msg string)]
+
+// ConfigLog sets up the default error logging callback for new connections.
+//
+// https://sqlite.org/errlog.html
+func ConfigLog(cb func(code ExtendedErrorCode, msg string)) {
+	defaultLogger.Store(&cb)
+}
+
 // ConfigLog sets up the error logging callback for the connection.
 //
 // https://sqlite.org/errlog.html
@@ -265,6 +275,10 @@ func traceCallback(ctx context.Context, mod api.Module, evt TraceEvent, pDB, pAr
 //
 // https://sqlite.org/c3ref/wal_checkpoint_v2.html
 func (c *Conn) WALCheckpoint(schema string, mode CheckpointMode) (nLog, nCkpt int, err error) {
+	if c.interrupt.Err() != nil {
+		return 0, 0, INTERRUPT
+	}
+
 	defer c.arena.mark()()
 	nLogPtr := c.arena.new(ptrlen)
 	nCkptPtr := c.arena.new(ptrlen)
@@ -378,6 +392,6 @@ func (c *Conn) EnableChecksums(schema string) error {
 	}
 
 	// Checkpoint the WAL.
-	_, _, err = c.WALCheckpoint(schema, CHECKPOINT_RESTART)
+	_, _, err = c.WALCheckpoint(schema, CHECKPOINT_FULL)
 	return err
 }

conn.go

@@ -3,6 +3,7 @@ package sqlite3
 import (
 	"context"
 	"fmt"
+	"iter"
 	"math"
 	"math/rand"
 	"net/url"
@@ -24,7 +25,6 @@ type Conn struct {
 	*sqlite
 
 	interrupt  context.Context
-	pending    *Stmt
 	stmts      []*Stmt
 	busy       func(context.Context, int) bool
 	log        func(xErrorCode, string)
@@ -40,6 +40,7 @@ type Conn struct {
 	busylst time.Time
 	arena   arena
 	handle  ptr_t
+	gosched uint8
 }
 
 // Open calls [OpenFlags] with [OPEN_READWRITE], [OPEN_CREATE] and [OPEN_URI].
@@ -48,7 +49,7 @@ func Open(filename string) (*Conn, error) {
 }
 
 // OpenContext is like [Open] but includes a context,
-// which is used to interrupt the process of opening the connectiton.
+// which is used to interrupt the process of opening the connection.
 func OpenContext(ctx context.Context, filename string) (*Conn, error) {
 	return newConn(ctx, filename, OPEN_READWRITE|OPEN_CREATE|OPEN_URI)
 }
@@ -91,6 +92,9 @@ func newConn(ctx context.Context, filename string, flags OpenFlag) (ret *Conn, _
 	}()
 
 	c.ctx = context.WithValue(c.ctx, connKey{}, c)
+	if logger := defaultLogger.Load(); logger != nil {
+		c.ConfigLog(*logger)
+	}
 	c.arena = c.newArena()
 	c.handle, err = c.openDB(filename, flags)
 	if err == nil {
@@ -116,7 +120,7 @@ func (c *Conn) openDB(filename string, flags OpenFlag) (ptr_t, error) {
 		return 0, err
 	}
 
-	c.call("sqlite3_progress_handler_go", stk_t(handle), 100)
+	c.call("sqlite3_progress_handler_go", stk_t(handle), 1000)
 	if flags|OPEN_URI != 0 && strings.HasPrefix(filename, "file:") {
 		var pragmas strings.Builder
 		if _, after, ok := strings.Cut(filename, "?"); ok {
@@ -128,7 +132,6 @@ func (c *Conn) openDB(filename string, flags OpenFlag) (ptr_t, error) {
 			}
 		}
 		if pragmas.Len() != 0 {
-			c.checkInterrupt(handle)
 			pragmaPtr := c.arena.string(pragmas.String())
 			rc := res_t(c.call("sqlite3_exec", stk_t(handle), stk_t(pragmaPtr), 0, 0, 0))
 			if err := c.sqlite.error(rc, handle, pragmas.String()); err != nil {
@@ -162,9 +165,6 @@ func (c *Conn) Close() error {
 		return nil
 	}
 
-	c.pending.Close()
-	c.pending = nil
-
 	rc := res_t(c.call("sqlite3_close", stk_t(c.handle)))
 	if err := c.error(rc); err != nil {
 		return err
@@ -179,11 +179,16 @@ func (c *Conn) Close() error {
 //
 // https://sqlite.org/c3ref/exec.html
 func (c *Conn) Exec(sql string) error {
-	defer c.arena.mark()()
-	sqlPtr := c.arena.string(sql)
+	if c.interrupt.Err() != nil {
+		return INTERRUPT
+	}
+	return c.exec(sql)
+}
 
-	c.checkInterrupt(c.handle)
-	rc := res_t(c.call("sqlite3_exec", stk_t(c.handle), stk_t(sqlPtr), 0, 0, 0))
+func (c *Conn) exec(sql string) error {
+	defer c.arena.mark()()
+	textPtr := c.arena.string(sql)
+	rc := res_t(c.call("sqlite3_exec", stk_t(c.handle), stk_t(textPtr), 0, 0, 0))
 	return c.error(rc, sql)
 }
 
@@ -202,20 +207,22 @@ func (c *Conn) PrepareFlags(sql string, flags PrepareFlag) (stmt *Stmt, tail str
 	if len(sql) > _MAX_SQL_LENGTH {
 		return nil, "", TOOBIG
 	}
+	if c.interrupt.Err() != nil {
+		return nil, "", INTERRUPT
+	}
 
 	defer c.arena.mark()()
 	stmtPtr := c.arena.new(ptrlen)
 	tailPtr := c.arena.new(ptrlen)
-	sqlPtr := c.arena.string(sql)
+	textPtr := c.arena.string(sql)
 
-	c.checkInterrupt(c.handle)
 	rc := res_t(c.call("sqlite3_prepare_v3", stk_t(c.handle),
-		stk_t(sqlPtr), stk_t(len(sql)+1), stk_t(flags),
+		stk_t(textPtr), stk_t(len(sql)+1), stk_t(flags),
 		stk_t(stmtPtr), stk_t(tailPtr)))
 
-	stmt = &Stmt{c: c}
+	stmt = &Stmt{c: c, sql: sql}
 	stmt.handle = util.Read32[ptr_t](c.mod, stmtPtr)
-	if sql := sql[util.Read32[ptr_t](c.mod, tailPtr)-sqlPtr:]; sql != "" {
+	if sql := sql[util.Read32[ptr_t](c.mod, tailPtr)-textPtr:]; sql != "" {
 		tail = sql
 	}
 
@@ -336,43 +343,17 @@ func (c *Conn) GetInterrupt() context.Context {
 //
 // https://sqlite.org/c3ref/interrupt.html
 func (c *Conn) SetInterrupt(ctx context.Context) (old context.Context) {
+	if ctx == nil {
+		panic("nil Context")
+	}
 	old = c.interrupt
 	c.interrupt = ctx
-
-	if ctx == old || ctx.Done() == old.Done() {
-		return old
-	}
-
-	// A busy SQL statement prevents SQLite from ignoring an interrupt
-	// that comes before any other statements are started.
-	if c.pending == nil {
-		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", stk_t(c.handle), stk_t(loopPtr), math.MaxUint64,
-			stk_t(PREPARE_PERSISTENT), stk_t(stmtPtr), 0)
-		c.pending = &Stmt{c: c}
-		c.pending.handle = util.Read32[ptr_t](c.mod, stmtPtr)
-	}
-
-	if old.Done() != nil && ctx.Err() == nil {
-		c.pending.Reset()
-	}
-	if ctx.Done() != nil {
-		c.pending.Step()
-	}
 	return old
 }
 
-func (c *Conn) checkInterrupt(handle ptr_t) {
-	if c.interrupt.Err() != nil {
-		c.call("sqlite3_interrupt", stk_t(handle))
-	}
-}
-
 func progressCallback(ctx context.Context, mod api.Module, _ ptr_t) (interrupt int32) {
 	if c, ok := ctx.Value(connKey{}).(*Conn); ok {
-		if c.interrupt.Done() != nil {
+		if c.gosched++; c.gosched%16 == 0 {
 			runtime.Gosched()
 		}
 		if c.interrupt.Err() != nil {
@@ -428,11 +409,8 @@ func (c *Conn) BusyHandler(cb func(ctx context.Context, count int) (retry bool))
 
 func busyCallback(ctx context.Context, mod api.Module, pDB ptr_t, count int32) (retry int32) {
 	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.busy != nil {
-		interrupt := c.interrupt
-		if interrupt == nil {
-			interrupt = context.Background()
-		}
-		if interrupt.Err() == nil && c.busy(interrupt, int(count)) {
+		if interrupt := c.interrupt; interrupt.Err() == nil &&
+			c.busy(interrupt, int(count)) {
 			retry = 1
 		}
 	}
@@ -503,10 +481,16 @@ func (c *Conn) error(rc res_t, 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
+// 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 func(yield func(*Stmt) bool) {
+		for _, s := range c.stmts {
+			if !yield(s) {
+				break
+			}
 		}
 	}
 }

conn_iter.go

@@ -1,11 +0,0 @@
-//go:build go1.23
-
-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

@@ -1,9 +0,0 @@
-//go:build !go1.23
-
-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

@@ -11,10 +11,9 @@ const (
 	_ROW  = 100 /* sqlite3_step() has another row ready */
 	_DONE = 101 /* sqlite3_step() has finished executing */
 
-	_MAX_NAME         = 1e6 // Self-imposed limit for most NUL terminated strings.
-	_MAX_LENGTH       = 1e9
-	_MAX_SQL_LENGTH   = 1e9
-	_MAX_FUNCTION_ARG = 100
+	_MAX_NAME       = 1e6 // Self-imposed limit for most NUL terminated strings.
+	_MAX_LENGTH     = 1e9
+	_MAX_SQL_LENGTH = 1e9
 
 	ptrlen = util.PtrLen
 	intlen = util.IntLen

context.go

@@ -89,20 +89,26 @@ func (ctx Context) ResultText(value string) {
 }
 
 // ResultRawText sets the text result of the function to a []byte.
-// Returning a nil slice is the same as calling [Context.ResultNull].
 //
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultRawText(value []byte) {
+	if len(value) == 0 {
+		ctx.ResultText("")
+		return
+	}
 	ptr := ctx.c.newBytes(value)
 	ctx.c.call("sqlite3_result_text_go",
 		stk_t(ctx.handle), stk_t(ptr), stk_t(len(value)))
 }
 
 // ResultBlob sets the result of the function to a []byte.
-// Returning a nil slice is the same as calling [Context.ResultNull].
 //
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultBlob(value []byte) {
+	if len(value) == 0 {
+		ctx.ResultZeroBlob(0)
+		return
+	}
 	ptr := ctx.c.newBytes(value)
 	ctx.c.call("sqlite3_result_blob_go",
 		stk_t(ctx.handle), stk_t(ptr), stk_t(len(value)))

driver/driver.go

@@ -20,22 +20,45 @@
 //   - a [serializable] transaction is always "immediate";
 //   - a [read-only] transaction is always "deferred".
 //
+// # Datatypes In SQLite
+//
+// SQLite is dynamically typed.
+// Columns can mostly hold any value regardless of their declared type.
+// SQLite supports most [driver.Value] types out of the box,
+// but bool and [time.Time] require special care.
+//
+// Booleans can be stored on any column type and scanned back to a *bool.
+// However, if scanned to a *any, booleans may either become an
+// int64, string or bool, depending on the declared type of the column.
+// If you use BOOLEAN for your column type,
+// 1 and 0 will always scan as true and false.
+//
 // # Working with time
 //
+// Time values can similarly be stored on any column type.
 // 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";
+// Special 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.
 //
-// If you encode as RFC 3339 (the default),
-// consider using the TIME [collating sequence] to produce a time-ordered sequence.
+// You can also set "_timefmt" to an arbitrary [sqlite3.TimeFormat] or [time.Layout].
 //
-// To scan values in other formats, [sqlite3.TimeFormat.Scanner] may be helpful.
-// To bind values in other formats, [sqlite3.TimeFormat.Encode] them before binding.
+// If you encode as RFC 3339 (the default),
+// consider using the TIME [collating sequence] to produce time-ordered sequences.
+//
+// If you encode as RFC 3339 (the default),
+// time values will scan back to a *time.Time unless your column type is TEXT.
+// Otherwise, if scanned to a *any, time values may either become an
+// int64, float64 or string, depending on the time format and declared type of the column.
+// If you use DATE, TIME, DATETIME, or TIMESTAMP for your column type,
+// "_timefmt" will be used to decode values.
+//
+// To scan values in custom formats, [sqlite3.TimeFormat.Scanner] may be helpful.
+// To bind values in custom 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].
@@ -48,7 +71,7 @@
 // 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, or nil,
-// depending on the column type and what whoever wrote the value.
+// depending on the column type and whoever wrote the value.
 // [sqlite3.TimeFormat.Decode] may help.
 //
 // # Setting PRAGMAs
@@ -358,13 +381,10 @@ func (c *conn) Commit() error {
 }
 
 func (c *conn) Rollback() error {
-	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(`ROLLBACK` + c.txReset)
-	}
-	return err
+	// ROLLBACK even if interrupted.
+	old := c.Conn.SetInterrupt(context.Background())
+	defer c.Conn.SetInterrupt(old)
+	return c.Conn.Exec(`ROLLBACK` + c.txReset)
 }
 
 func (c *conn) Prepare(query string) (driver.Stmt, error) {
@@ -598,6 +618,28 @@ const (
 	_TIME
 )
 
+func scanFromDecl(decl string) scantype {
+	// These types are only used before we have rows,
+	// and otherwise as type hints.
+	// The first few ensure STRICT tables are strictly typed.
+	// The other two are type hints for booleans and time.
+	switch decl {
+	case "INT", "INTEGER":
+		return _INT
+	case "REAL":
+		return _REAL
+	case "TEXT":
+		return _TEXT
+	case "BLOB":
+		return _BLOB
+	case "BOOLEAN":
+		return _BOOL
+	case "DATE", "TIME", "DATETIME", "TIMESTAMP":
+		return _TIME
+	}
+	return _ANY
+}
+
 var (
 	// Ensure these interfaces are implemented:
 	_ driver.RowsColumnTypeDatabaseTypeName = &rows{}
@@ -622,6 +664,18 @@ func (r *rows) Columns() []string {
 	return r.names
 }
 
+func (r *rows) scanType(index int) scantype {
+	if r.scans == nil {
+		count := r.Stmt.ColumnCount()
+		scans := make([]scantype, count)
+		for i := range scans {
+			scans[i] = scanFromDecl(strings.ToUpper(r.Stmt.ColumnDeclType(i)))
+		}
+		r.scans = scans
+	}
+	return r.scans[index]
+}
+
 func (r *rows) loadColumnMetadata() {
 	if r.nulls == nil {
 		count := r.Stmt.ColumnCount()
@@ -635,24 +689,7 @@ func (r *rows) loadColumnMetadata() {
 					r.Stmt.ColumnTableName(i),
 					col)
 				types[i] = strings.ToUpper(types[i])
-				// These types are only used before we have rows,
-				// and otherwise as type hints.
-				// The first few ensure STRICT tables are strictly typed.
-				// The other two are type hints for booleans and time.
-				switch types[i] {
-				case "INT", "INTEGER":
-					scans[i] = _INT
-				case "REAL":
-					scans[i] = _REAL
-				case "TEXT":
-					scans[i] = _TEXT
-				case "BLOB":
-					scans[i] = _BLOB
-				case "BOOLEAN":
-					scans[i] = _BOOL
-				case "DATE", "TIME", "DATETIME", "TIMESTAMP":
-					scans[i] = _TIME
-				}
+				scans[i] = scanFromDecl(types[i])
 			}
 		}
 		r.nulls = nulls
@@ -661,27 +698,15 @@ func (r *rows) loadColumnMetadata() {
 	}
 }
 
-func (r *rows) declType(index int) string {
-	if r.types == nil {
-		count := r.Stmt.ColumnCount()
-		types := make([]string, count)
-		for i := range types {
-			types[i] = strings.ToUpper(r.Stmt.ColumnDeclType(i))
-		}
-		r.types = types
-	}
-	return r.types[index]
-}
-
 func (r *rows) ColumnTypeDatabaseTypeName(index int) string {
 	r.loadColumnMetadata()
-	decltype := r.types[index]
-	if len := len(decltype); len > 0 && decltype[len-1] == ')' {
-		if i := strings.LastIndexByte(decltype, '('); i >= 0 {
-			decltype = decltype[:i]
+	decl := r.types[index]
+	if len := len(decl); len > 0 && decl[len-1] == ')' {
+		if i := strings.LastIndexByte(decl, '('); i >= 0 {
+			decl = decl[:i]
 		}
 	}
-	return strings.TrimSpace(decltype)
+	return strings.TrimSpace(decl)
 }
 
 func (r *rows) ColumnTypeNullable(index int) (nullable, ok bool) {
@@ -748,36 +773,49 @@ func (r *rows) Next(dest []driver.Value) error {
 	}
 
 	data := unsafe.Slice((*any)(unsafe.SliceData(dest)), len(dest))
-	err := r.Stmt.Columns(data...)
+	if err := r.Stmt.ColumnsRaw(data...); err != nil {
+		return err
+	}
 	for i := range dest {
-		if t, ok := r.decodeTime(i, dest[i]); ok {
-			dest[i] = t
-		}
-	}
-	return err
-}
-
-func (r *rows) decodeTime(i int, v any) (_ time.Time, ok bool) {
-	switch v := v.(type) {
-	case int64, float64:
-		// could be a time value
-	case string:
-		if r.tmWrite != "" && r.tmWrite != time.RFC3339 && r.tmWrite != time.RFC3339Nano {
+		scan := r.scanType(i)
+		switch v := dest[i].(type) {
+		case int64:
+			if scan == _BOOL {
+				switch v {
+				case 1:
+					dest[i] = true
+				case 0:
+					dest[i] = false
+				}
+				continue
+			}
+		case []byte:
+			if len(v) == cap(v) { // a BLOB
+				continue
+			}
+			if scan != _TEXT {
+				switch r.tmWrite {
+				case "", time.RFC3339, time.RFC3339Nano:
+					t, ok := maybeTime(v)
+					if ok {
+						dest[i] = t
+						continue
+					}
+				}
+			}
+			dest[i] = string(v)
+		case float64:
 			break
+		default:
+			continue
 		}
-		t, ok := maybeTime(v)
-		if ok {
-			return t, true
+		if scan == _TIME {
+			t, err := r.tmRead.Decode(dest[i])
+			if err == nil {
+				dest[i] = t
+				continue
+			}
 		}
-	default:
-		return
 	}
-	switch r.declType(i) {
-	case "DATE", "TIME", "DATETIME", "TIMESTAMP":
-		// could be a time value
-	default:
-		return
-	}
-	t, err := r.tmRead.Decode(v)
-	return t, err == nil
+	return nil
 }

driver/driver_test.go

@@ -199,6 +199,62 @@ func Test_BeginTx(t *testing.T) {
 	}
 }
 
+func Test_nested_context(t *testing.T) {
+	t.Parallel()
+	tmp := memdb.TestDB(t)
+
+	db, err := sql.Open("sqlite3", tmp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	tx, err := db.Begin()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer tx.Rollback()
+
+	outer, err := tx.Query(`SELECT value FROM generate_series(0)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer outer.Close()
+
+	want := func(rows *sql.Rows, want int) {
+		t.Helper()
+
+		var got int
+		rows.Next()
+		if err := rows.Scan(&got); err != nil {
+			t.Fatal(err)
+		}
+		if got != want {
+			t.Errorf("got %d, want %d", got, want)
+		}
+	}
+
+	want(outer, 0)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	inner, err := tx.QueryContext(ctx, `SELECT value FROM generate_series(0)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer inner.Close()
+
+	want(inner, 0)
+	cancel()
+
+	if inner.Next() || !errors.Is(inner.Err(), sqlite3.INTERRUPT) {
+		t.Fatal(inner.Err())
+	}
+
+	want(outer, 1)
+}
+
 func Test_Prepare(t *testing.T) {
 	t.Parallel()
 	tmp := memdb.TestDB(t)
@@ -467,3 +523,29 @@ func Test_ColumnType_ScanType(t *testing.T) {
 		t.Fatal(err)
 	}
 }
+
+func Benchmark_loop(b *testing.B) {
+	db, err := Open(":memory:")
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer db.Close()
+
+	var version string
+	err = db.QueryRow(`SELECT sqlite_version();`).Scan(&version)
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	b.Cleanup(cancel)
+
+	b.ResetTimer()
+	for range b.N {
+		_, err := db.ExecContext(ctx,
+			`WITH RECURSIVE c(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM c WHERE x < 1000000) SELECT x FROM c;`)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}

driver/example2_test.go

@@ -1,9 +1,5 @@
-//go:build linux || darwin || windows || freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock || sqlite3_dotlk
-
 package driver_test
 
-// Adapted from: https://go.dev/doc/tutorial/database-access
-
 import (
 	"database/sql"
 	"database/sql/driver"
@@ -27,7 +23,7 @@ func Example_customTime() {
 	_, err = db.Exec(`
 		CREATE TABLE data (
 			id INTEGER PRIMARY KEY,
-			date_time TEXT
+			date_time ANY
 		) STRICT;
 	`)
 	if err != nil {

driver/time.go

@@ -1,12 +1,15 @@
 package driver
 
-import "time"
+import (
+	"bytes"
+	"time"
+)
 
 // Convert a string in [time.RFC3339Nano] format into a [time.Time]
 // if it roundtrips back to the same string.
 // This way times can be persisted to, and recovered from, the database,
 // but if a string is needed, [database/sql] will recover the same string.
-func maybeTime(text string) (_ time.Time, _ bool) {
+func maybeTime(text []byte) (_ time.Time, _ bool) {
 	// Weed out (some) values that can't possibly be
 	// [time.RFC3339Nano] timestamps.
 	if len(text) < len("2006-01-02T15:04:05Z") {
@@ -21,8 +24,8 @@ func maybeTime(text string) (_ time.Time, _ bool) {
 
 	// Slow path.
 	var buf [len(time.RFC3339Nano)]byte
-	date, err := time.Parse(time.RFC3339Nano, text)
-	if err == nil && text == string(date.AppendFormat(buf[:0], time.RFC3339Nano)) {
+	date, err := time.Parse(time.RFC3339Nano, string(text))
+	if err == nil && bytes.Equal(text, date.AppendFormat(buf[:0], time.RFC3339Nano)) {
 		return date, true
 	}
 	return

driver/time_test.go

@@ -22,7 +22,7 @@ func Fuzz_stringOrTime_1(f *testing.F) {
 	f.Add("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.")
 
 	f.Fuzz(func(t *testing.T, str string) {
-		v, ok := maybeTime(str)
+		v, ok := maybeTime([]byte(str))
 		if ok {
 			// Make sure times round-trip to the same string:
 			// https://pkg.go.dev/database/sql#Rows.Scan
@@ -51,7 +51,7 @@ func Fuzz_stringOrTime_2(f *testing.F) {
 	f.Add(int64(-763421161058), int64(222_222_222)) // twosday, year 22222BC
 
 	checkTime := func(t testing.TB, date time.Time) {
-		v, ok := maybeTime(date.Format(time.RFC3339Nano))
+		v, ok := maybeTime(date.AppendFormat(nil, time.RFC3339Nano))
 		if ok {
 			// Make sure times round-trip to the same time:
 			if !v.Equal(date) {

embed/bcw2/build.sh

@@ -17,6 +17,7 @@ cp "$ROOT"/sqlite3/*.patch build/
 curl -# https://sqlite.org/src/tarball/sqlite.tar.gz?r=c09656c6 | tar xz
 
 cd sqlite
+cat ../repro.patch | patch -p0 --no-backup-if-mismatch
 if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" ]]; then
 	MSYS_NO_PATHCONV=1 nmake /f makefile.msc sqlite3.c "OPTS=-DSQLITE_ENABLE_UPDATE_DELETE_LIMIT -DSQLITE_ENABLE_ORDERED_SET_AGGREGATES"
 else

embed/bcw2/go.mod

@@ -1,14 +1,14 @@
 module github.com/ncruces/go-sqlite3/embed/bcw2
 
-go 1.22.0
+go 1.23.0
 
 toolchain go1.24.0
 
-require github.com/ncruces/go-sqlite3 v0.23.0
+require github.com/ncruces/go-sqlite3 v0.24.0
 
 require (
 	github.com/ncruces/julianday v1.0.0 // indirect
 	github.com/ncruces/sort v0.1.5 // indirect
-	github.com/tetratelabs/wazero v1.8.2 // indirect
+	github.com/tetratelabs/wazero v1.9.0 // indirect
 	golang.org/x/sys v0.30.0 // indirect
 )

embed/bcw2/go.sum

@@ -1,11 +1,11 @@
-github.com/ncruces/go-sqlite3 v0.23.0 h1:90j/ar8Ywu2AtsfDl5WhO9sgP/rNk76BcKGIzAHO8AQ=
-github.com/ncruces/go-sqlite3 v0.23.0/go.mod h1:gq2nriHSczOs11SqGW5+0X+SgLdkdj4K+j4F/AhQ+8g=
+github.com/ncruces/go-sqlite3 v0.24.0 h1:Z4jfmzu2NCd4SmyFwLT2OmF3EnTZbqwATvdiuNHNhLA=
+github.com/ncruces/go-sqlite3 v0.24.0/go.mod h1:/Vs8ACZHjJ1SA6E9RZUn3EyB1OP3nDQ4z/ar+0fplTQ=
 github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M=
 github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
 github.com/ncruces/sort v0.1.5 h1:fiFWXXAqKI8QckPf/6hu/bGFwcEPrirIOFaJqWujs4k=
 github.com/ncruces/sort v0.1.5/go.mod h1:obJToO4rYr6VWP0Uw5FYymgYGt3Br4RXcs/JdKaXAPk=
-github.com/tetratelabs/wazero v1.8.2 h1:yIgLR/b2bN31bjxwXHD8a3d+BogigR952csSDdLYEv4=
-github.com/tetratelabs/wazero v1.8.2/go.mod h1:yAI0XTsMBhREkM/YDAK/zNou3GoiAce1P6+rp/wQhjs=
+github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
+github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
 golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
 golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=

embed/bcw2/repro.patch

@@ -0,0 +1,23 @@
+# https://sqlite.org/src/vpatch?from=67809715977a5bad&to=3f57584710d61174
+--- tool/mkpragmatab.tcl
++++ tool/mkpragmatab.tcl
+@@ -526,14 +526,17 @@
+   puts $fd [format {#define PragFlg_%-10s 0x%02x /* %s */} \
+              $f $fv $flagMeaning($f)]
+   set fv [expr {$fv*2}]
+ }
+ 
+-# Sort the column lists so that longer column lists occur first
++# Sort the column lists so that longer column lists occur first.
++# In the event of a tie, sort column lists lexicographically.
+ #
+ proc colscmp {a b} {
+-  return [expr {[llength $b] - [llength $a]}]
++  set rc [expr {[llength $b] - [llength $a]}]
++  if {$rc} {return $rc}
++  return [string compare $a $b]
+ }
+ set cols_list [lsort -command colscmp $cols_list]
+ 
+ # Generate the array of column names used by pragmas that act like
+ # queries.

embed/exports.txt

@@ -80,6 +80,7 @@ sqlite3_interrupt
 sqlite3_invoke_busy_handler_go
 sqlite3_last_insert_rowid
 sqlite3_limit
+sqlite3_log_go
 sqlite3_malloc64
 sqlite3_open_v2
 sqlite3_overload_function

error.go

@@ -2,7 +2,6 @@ package sqlite3
 
 import (
 	"errors"
-	"strconv"
 	"strings"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
@@ -12,7 +11,6 @@ import (
 //
 // https://sqlite.org/c3ref/errcode.html
 type Error struct {
-	str  string
 	msg  string
 	sql  string
 	code res_t
@@ -29,19 +27,13 @@ func (e *Error) Code() ErrorCode {
 //
 // https://sqlite.org/rescode.html
 func (e *Error) ExtendedCode() ExtendedErrorCode {
-	return ExtendedErrorCode(e.code)
+	return xErrorCode(e.code)
 }
 
 // Error implements the error interface.
 func (e *Error) Error() string {
 	var b strings.Builder
-	b.WriteString("sqlite3: ")
-
-	if e.str != "" {
-		b.WriteString(e.str)
-	} else {
-		b.WriteString(strconv.Itoa(int(e.code)))
-	}
+	b.WriteString(util.ErrorCodeString(uint32(e.code)))
 
 	if e.msg != "" {
 		b.WriteString(": ")
@@ -103,12 +95,12 @@ func (e ErrorCode) Error() string {
 
 // Temporary returns true for [BUSY] errors.
 func (e ErrorCode) Temporary() bool {
-	return e == BUSY
+	return e == BUSY || e == INTERRUPT
 }
 
 // ExtendedCode returns the extended error code for this error.
 func (e ErrorCode) ExtendedCode() ExtendedErrorCode {
-	return ExtendedErrorCode(e)
+	return xErrorCode(e)
 }
 
 // Error implements the error interface.
@@ -133,7 +125,7 @@ func (e ExtendedErrorCode) As(err any) bool {
 
 // Temporary returns true for [BUSY] errors.
 func (e ExtendedErrorCode) Temporary() bool {
-	return ErrorCode(e) == BUSY
+	return ErrorCode(e) == BUSY || ErrorCode(e) == INTERRUPT
 }
 
 // Timeout returns true for [BUSY_TIMEOUT] errors.

error_test.go

@@ -43,7 +43,7 @@ func TestError(t *testing.T) {
 	if !errors.Is(err, xErrorCode(0x8080)) {
 		t.Errorf("want true")
 	}
-	if s := err.Error(); s != "sqlite3: 32896" {
+	if s := err.Error(); s != "sqlite3: unknown error" {
 		t.Errorf("got %q", s)
 	}
 	if ok := errors.As(err.ExtendedCode(), &ecode); !ok || ecode != ErrorCode(0x80) {
@@ -83,7 +83,7 @@ func TestError_Temporary(t *testing.T) {
 				}
 			}
 			{
-				err := ExtendedErrorCode(tt.code)
+				err := xErrorCode(tt.code)
 				if got := err.Temporary(); got != tt.want {
 					t.Errorf("ExtendedErrorCode.Temporary(%d) = %v, want %v", tt.code, got, tt.want)
 				}
@@ -115,7 +115,7 @@ func TestError_Timeout(t *testing.T) {
 				}
 			}
 			{
-				err := ExtendedErrorCode(tt.code)
+				err := xErrorCode(tt.code)
 				if got := err.Timeout(); got != tt.want {
 					t.Errorf("Error.Timeout(%d) = %v, want %v", tt.code, got, tt.want)
 				}
@@ -156,12 +156,12 @@ func Test_ExtendedErrorCode_Error(t *testing.T) {
 	defer db.Close()
 
 	// Test all extended error codes.
-	for i := 0; i == int(ExtendedErrorCode(i)); i++ {
+	for i := 0; i == int(xErrorCode(i)); i++ {
 		want := "sqlite3: "
 		ptr := ptr_t(db.call("sqlite3_errstr", stk_t(i)))
 		want += util.ReadString(db.mod, ptr, _MAX_NAME)
 
-		got := ExtendedErrorCode(i).Error()
+		got := xErrorCode(i).Error()
 		if got != want {
 			t.Fatalf("got %q, want %q, with %d", got, want, i)
 		}

ext/bloom/bloom.go

@@ -268,13 +268,13 @@ func (b *bloom) Open() (sqlite3.VTabCursor, error) {
 
 type cursor struct {
 	*bloom
-	arg *sqlite3.Value
+	arg sqlite3.Value
 	eof bool
 }
 
 func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
 	c.eof = false
-	c.arg = &arg[0]
+	c.arg = arg[0]
 	blob := arg[0].RawBlob()
 
 	f, err := c.db.OpenBlob(c.schema, c.storage, "data", 1, false)
@@ -312,7 +312,7 @@ func (c *cursor) Column(ctx sqlite3.Context, n int) error {
 	case 0:
 		ctx.ResultBool(true)
 	case 1:
-		ctx.ResultValue(*c.arg)
+		ctx.ResultValue(c.arg)
 	}
 	return nil
 }

ext/fileio/coro.go

@@ -1,70 +0,0 @@
-//go:build !go1.23
-
-package fileio
-
-import (
-	"fmt"
-
-	"github.com/ncruces/go-sqlite3/internal/util"
-)
-
-// Adapted from: https://research.swtch.com/coro
-
-const errCoroCanceled = util.ErrorString("coroutine canceled")
-
-func coroNew[In, Out any](f func(In, func(Out) In) Out) (resume func(In) (Out, bool), cancel func()) {
-	type msg[T any] struct {
-		panic any
-		val   T
-	}
-
-	cin := make(chan msg[In])
-	cout := make(chan msg[Out])
-	running := true
-	resume = func(in In) (out Out, ok bool) {
-		if !running {
-			return
-		}
-		cin <- msg[In]{val: in}
-		m := <-cout
-		if m.panic != nil {
-			panic(m.panic)
-		}
-		return m.val, running
-	}
-	cancel = func() {
-		if !running {
-			return
-		}
-		e := fmt.Errorf("%w", errCoroCanceled)
-		cin <- msg[In]{panic: e}
-		m := <-cout
-		if m.panic != nil && m.panic != e {
-			panic(m.panic)
-		}
-	}
-	yield := func(out Out) In {
-		cout <- msg[Out]{val: out}
-		m := <-cin
-		if m.panic != nil {
-			panic(m.panic)
-		}
-		return m.val
-	}
-	go func() {
-		defer func() {
-			if running {
-				running = false
-				cout <- msg[Out]{panic: recover()}
-			}
-		}()
-		var out Out
-		m := <-cin
-		if m.panic == nil {
-			out = f(m.val, yield)
-		}
-		running = false
-		cout <- msg[Out]{val: out}
-	}()
-	return resume, cancel
-}

ext/fileio/fileio.go

@@ -42,7 +42,7 @@ func lsmode(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	ctx.ResultText(fs.FileMode(arg[0].Int()).String())
 }
 
-func readfile(fsys fs.FS) func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+func readfile(fsys fs.FS) sqlite3.ScalarFunction {
 	return func(ctx sqlite3.Context, arg ...sqlite3.Value) {
 		var err error
 		var data []byte

ext/fileio/fsdir.go

@@ -2,6 +2,7 @@ package fileio
 
 import (
 	"io/fs"
+	"iter"
 	"os"
 	"path"
 	"path/filepath"
@@ -62,12 +63,12 @@ func (d fsdir) Open() (sqlite3.VTabCursor, error) {
 
 type cursor struct {
 	fsdir
-	base   string
-	resume resume
-	cancel func()
-	curr   entry
-	eof    bool
-	rowID  int64
+	base  string
+	next  func() (entry, bool)
+	stop  func()
+	curr  entry
+	eof   bool
+	rowID int64
 }
 
 type entry struct {
@@ -77,8 +78,8 @@ type entry struct {
 }
 
 func (c *cursor) Close() error {
-	if c.cancel != nil {
-		c.cancel()
+	if c.stop != nil {
+		c.stop()
 	}
 	return nil
 }
@@ -101,14 +102,26 @@ func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
 		c.base = base
 	}
 
-	c.resume, c.cancel = pull(c, root)
+	c.next, c.stop = 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)
+		}
+	})
 	c.eof = false
 	c.rowID = 0
 	return c.Next()
 }
 
 func (c *cursor) Next() error {
-	curr, ok := next(c)
+	curr, ok := c.next()
 	c.curr = curr
 	c.eof = !ok
 	c.rowID++

ext/fileio/fsdir_coro.go

@@ -1,29 +0,0 @@
-//go:build !go1.23
-
-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

@@ -1,31 +0,0 @@
-//go:build go1.23
-
-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/ipaddr/ipaddr.go

@@ -0,0 +1,113 @@
+// Package ipaddr provides functions to manipulate IPs and CIDRs.
+//
+// It provides the following functions:
+//   - ipcontains(prefix, ip)
+//   - ipoverlaps(prefix1, prefix2)
+//   - ipfamily(ip/prefix)
+//   - iphost(ip/prefix)
+//   - ipmasklen(prefix)
+//   - ipnetwork(prefix)
+package ipaddr
+
+import (
+	"errors"
+	"net/netip"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+// Register IP/CIDR functions for a database connection.
+func Register(db *sqlite3.Conn) error {
+	const flags = sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
+	return errors.Join(
+		db.CreateFunction("ipcontains", 2, flags, contains),
+		db.CreateFunction("ipoverlaps", 2, flags, overlaps),
+		db.CreateFunction("ipfamily", 1, flags, family),
+		db.CreateFunction("iphost", 1, flags, host),
+		db.CreateFunction("ipmasklen", 1, flags, masklen),
+		db.CreateFunction("ipnetwork", 1, flags, network))
+}
+
+func contains(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	prefix, err := netip.ParsePrefix(arg[0].Text())
+	if err != nil {
+		ctx.ResultError(err)
+		return // notest
+	}
+	addr, err := netip.ParseAddr(arg[1].Text())
+	if err != nil {
+		ctx.ResultError(err)
+		return // notest
+	}
+	ctx.ResultBool(prefix.Contains(addr))
+}
+
+func overlaps(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	prefix1, err := netip.ParsePrefix(arg[0].Text())
+	if err != nil {
+		ctx.ResultError(err)
+		return // notest
+	}
+	prefix2, err := netip.ParsePrefix(arg[0].Text())
+	if err != nil {
+		ctx.ResultError(err)
+		return // notest
+	}
+	ctx.ResultBool(prefix1.Overlaps(prefix2))
+}
+
+func family(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	addr, err := addr(arg[0].Text())
+	if err != nil {
+		ctx.ResultError(err)
+		return // notest
+	}
+	switch {
+	case addr.Is4():
+		ctx.ResultInt(4)
+	case addr.Is6():
+		ctx.ResultInt(6)
+	}
+}
+
+func host(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	addr, err := addr(arg[0].Text())
+	if err != nil {
+		ctx.ResultError(err)
+		return // notest
+	}
+	buf, _ := addr.MarshalText()
+	ctx.ResultRawText(buf)
+}
+
+func masklen(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	prefix, err := netip.ParsePrefix(arg[0].Text())
+	if err != nil {
+		ctx.ResultError(err)
+		return // notest
+	}
+	ctx.ResultInt(prefix.Bits())
+}
+
+func network(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	prefix, err := netip.ParsePrefix(arg[0].Text())
+	if err != nil {
+		ctx.ResultError(err)
+		return // notest
+	}
+	buf, _ := prefix.Masked().MarshalText()
+	ctx.ResultRawText(buf)
+}
+
+func addr(text string) (netip.Addr, error) {
+	addr, err := netip.ParseAddr(text)
+	if err != nil {
+		if prefix, err := netip.ParsePrefix(text); err == nil {
+			return prefix.Addr(), nil
+		}
+		if addrpt, err := netip.ParseAddrPort(text); err == nil {
+			return addrpt.Addr(), nil
+		}
+	}
+	return addr, err
+}

ext/ipaddr/ipaddr_test.go

@@ -0,0 +1,88 @@
+package ipaddr_test
+
+import (
+	"testing"
+
+	"github.com/ncruces/go-sqlite3/driver"
+	_ "github.com/ncruces/go-sqlite3/embed"
+	"github.com/ncruces/go-sqlite3/ext/ipaddr"
+	_ "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(tmp, ipaddr.Register)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	var got string
+
+	err = db.QueryRow(`SELECT ipfamily('::1')`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "6" {
+		t.Fatalf("got %s", got)
+	}
+
+	err = db.QueryRow(`SELECT ipfamily('[::1]:80')`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "6" {
+		t.Fatalf("got %s", got)
+	}
+
+	err = db.QueryRow(`SELECT ipfamily('192.168.1.5/24')`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "4" {
+		t.Fatalf("got %s", got)
+	}
+
+	err = db.QueryRow(`SELECT iphost('192.168.1.5/24')`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "192.168.1.5" {
+		t.Fatalf("got %s", got)
+	}
+
+	err = db.QueryRow(`SELECT ipmasklen('192.168.1.5/24')`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "24" {
+		t.Fatalf("got %s", got)
+	}
+
+	err = db.QueryRow(`SELECT ipnetwork('192.168.1.5/24')`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "192.168.1.0/24" {
+		t.Fatalf("got %s", got)
+	}
+
+	err = db.QueryRow(`SELECT ipcontains('192.168.1.0/24', '192.168.1.5')`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "1" {
+		t.Fatalf("got %s", got)
+	}
+
+	err = db.QueryRow(`SELECT ipoverlaps('192.168.1.0/24', '192.168.1.5/32')`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "1" {
+		t.Fatalf("got %s", got)
+	}
+}

ext/regexp/regexp.go

@@ -111,22 +111,24 @@ loop2:
 	return glob.String()
 }
 
-func load(ctx sqlite3.Context, i int, expr string) (*regexp.Regexp, error) {
+func load(ctx sqlite3.Context, arg []sqlite3.Value, i int) (*regexp.Regexp, error) {
 	re, ok := ctx.GetAuxData(i).(*regexp.Regexp)
 	if !ok {
-		r, err := regexp.Compile(expr)
-		if err != nil {
-			return nil, err
+		re, ok = arg[i].Pointer().(*regexp.Regexp)
+		if !ok {
+			r, err := regexp.Compile(arg[i].Text())
+			if err != nil {
+				return nil, err
+			}
+			re = r
 		}
-		re = r
-		ctx.SetAuxData(0, r)
+		ctx.SetAuxData(i, re)
 	}
 	return re, nil
 }
 
 func regex(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	_ = arg[1] // bounds check
-	re, err := load(ctx, 0, arg[0].Text())
+	re, err := load(ctx, arg, 0)
 	if err != nil {
 		ctx.ResultError(err)
 		return // notest
@@ -136,18 +138,17 @@ func regex(ctx sqlite3.Context, arg ...sqlite3.Value) {
 }
 
 func regexLike(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	re, err := load(ctx, 1, arg[1].Text())
+	re, err := load(ctx, arg, 1)
 	if err != nil {
 		ctx.ResultError(err)
 		return // notest
 	}
-
 	text := arg[0].RawText()
 	ctx.ResultBool(re.Match(text))
 }
 
 func regexCount(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	re, err := load(ctx, 1, arg[1].Text())
+	re, err := load(ctx, arg, 1)
 	if err != nil {
 		ctx.ResultError(err)
 		return // notest
@@ -162,7 +163,7 @@ func regexCount(ctx sqlite3.Context, arg ...sqlite3.Value) {
 }
 
 func regexSubstr(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	re, err := load(ctx, 1, arg[1].Text())
+	re, err := load(ctx, arg, 1)
 	if err != nil {
 		ctx.ResultError(err)
 		return // notest
@@ -187,7 +188,7 @@ func regexSubstr(ctx sqlite3.Context, arg ...sqlite3.Value) {
 }
 
 func regexInstr(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	re, err := load(ctx, 1, arg[1].Text())
+	re, err := load(ctx, arg, 1)
 	if err != nil {
 		ctx.ResultError(err)
 		return // notest
@@ -215,16 +216,14 @@ func regexInstr(ctx sqlite3.Context, arg ...sqlite3.Value) {
 }
 
 func regexReplace(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	_ = arg[2] // bounds check
-
-	re, err := load(ctx, 1, arg[1].Text())
+	re, err := load(ctx, arg, 1)
 	if err != nil {
 		ctx.ResultError(err)
 		return // notest
 	}
 
-	text := arg[0].RawText()
 	repl := arg[2].RawText()
+	text := arg[0].RawText()
 	var pos, n int
 	if len(arg) > 3 {
 		pos = arg[3].Int()

ext/regexp/regexp_test.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"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"
@@ -104,6 +105,27 @@ func TestRegister_errors(t *testing.T) {
 	}
 }
 
+func TestRegister_pointer(t *testing.T) {
+	t.Parallel()
+	tmp := memdb.TestDB(t)
+
+	db, err := driver.Open(tmp, Register)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	var got int
+	err = db.QueryRow(`SELECT regexp_count('ABCABCAXYaxy', ?, 1)`,
+		sqlite3.Pointer(regexp.MustCompile(`(?i)A.`))).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != 4 {
+		t.Errorf("got %d, want %d", got, 4)
+	}
+}
+
 func TestGlobPrefix(t *testing.T) {
 	tests := []struct {
 		re   string

ext/statement/stmt.go

@@ -159,8 +159,6 @@ func (c *cursor) Close() error {
 }
 
 func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
-	c.arg = arg
-	c.rowID = 0
 	err := errors.Join(
 		c.stmt.Reset(),
 		c.stmt.ClearBindings())
@@ -187,6 +185,8 @@ func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
 			return err
 		}
 	}
+	c.arg = append(c.arg[:0], arg...)
+	c.rowID = 0
 	return c.Next()
 }
 

ext/stats/boolean.go

@@ -7,7 +7,7 @@ const (
 	some
 )
 
-func newBoolean(kind int) func() sqlite3.AggregateFunction {
+func newBoolean(kind int) sqlite3.AggregateConstructor {
 	return func() sqlite3.AggregateFunction { return &boolean{kind: kind} }
 }
 

ext/stats/percentile.go

@@ -21,7 +21,7 @@ const (
 	percentile_disc
 )
 
-func newPercentile(kind int) func() sqlite3.AggregateFunction {
+func newPercentile(kind int) sqlite3.AggregateConstructor {
 	return func() sqlite3.AggregateFunction { return &percentile{kind: kind} }
 }
 

ext/stats/stats.go

@@ -130,7 +130,7 @@ func special(kind int, n int64) (null, zero bool) {
 	}
 }
 
-func newVariance(kind int) func() sqlite3.AggregateFunction {
+func newVariance(kind int) sqlite3.AggregateConstructor {
 	return func() sqlite3.AggregateFunction { return &variance{kind: kind} }
 }
 
@@ -178,7 +178,7 @@ func (fn *variance) Inverse(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	}
 }
 
-func newCovariance(kind int) func() sqlite3.AggregateFunction {
+func newCovariance(kind int) sqlite3.AggregateConstructor {
 	return func() sqlite3.AggregateFunction { return &covariance{kind: kind} }
 }
 
@@ -254,7 +254,7 @@ func (fn *covariance) Inverse(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	}
 }
 
-func newMoments(kind int) func() sqlite3.AggregateFunction {
+func newMoments(kind int) sqlite3.AggregateConstructor {
 	return func() sqlite3.AggregateFunction { return &momentfn{kind: kind} }
 }
 

ext/unicode/unicode.go

@@ -1,21 +1,22 @@
 // Package unicode provides an alternative to the SQLite ICU extension.
 //
 // Like the [ICU extension], it provides Unicode aware:
-//   - upper() and lower() functions,
-//   - LIKE and REGEXP operators,
-//   - collation sequences.
+//   - upper() and lower() functions
+//   - LIKE and REGEXP operators
+//   - collation sequences
 //
-// The implementation is not 100% compatible with the [ICU extension]:
-//   - upper() and lower() use [strings.ToUpper], [strings.ToLower] and [cases];
-//   - the LIKE operator follows [strings.EqualFold] rules;
-//   - the REGEXP operator uses Go [regexp/syntax];
-//   - collation sequences use [collate].
+// Like PostgreSQL, it also provides:
+//   - initcap()
+//   - casefold()
+//   - normalize()
+//   - unaccent()
 //
-// It also provides (approximately) from PostgreSQL:
-//   - casefold(),
-//   - initcap(),
-//   - normalize(),
-//   - unaccent().
+// The implementations are not 100% compatible:
+//   - upper(), lower(), initcap() casefold() use [strings.ToUpper], [strings.ToLower], [strings.Title] and [cases]
+//   - normalize(), unaccent() use [transform] and [unicode.Mn]
+//   - the LIKE operator follows [strings.EqualFold] rules
+//   - the REGEXP operator uses Go [regexp/syntax]
+//   - collation sequences use [collate]
 //
 // Expect subtle differences (e.g.) in the handling of Turkish case folding.
 //
@@ -27,6 +28,7 @@ import (
 	"errors"
 	"regexp"
 	"strings"
+	"sync"
 	"unicode"
 	"unicode/utf8"
 
@@ -113,9 +115,8 @@ func upper(ctx sqlite3.Context, arg ...sqlite3.Value) {
 			ctx.ResultError(err)
 			return // notest
 		}
-		c := cases.Upper(t)
-		ctx.SetAuxData(1, c)
-		cs = c
+		cs = cases.Upper(t)
+		ctx.SetAuxData(1, cs)
 	}
 	ctx.ResultRawText(cs.Bytes(arg[0].RawText()))
 }
@@ -132,9 +133,8 @@ func lower(ctx sqlite3.Context, arg ...sqlite3.Value) {
 			ctx.ResultError(err)
 			return // notest
 		}
-		c := cases.Lower(t)
-		ctx.SetAuxData(1, c)
-		cs = c
+		cs = cases.Lower(t)
+		ctx.SetAuxData(1, cs)
 	}
 	ctx.ResultRawText(cs.Bytes(arg[0].RawText()))
 }
@@ -151,9 +151,8 @@ func initcap(ctx sqlite3.Context, arg ...sqlite3.Value) {
 			ctx.ResultError(err)
 			return // notest
 		}
-		c := cases.Title(t)
-		ctx.SetAuxData(1, c)
-		cs = c
+		cs = cases.Title(t)
+		ctx.SetAuxData(1, cs)
 	}
 	ctx.ResultRawText(cs.Bytes(arg[0].RawText()))
 }
@@ -162,8 +161,16 @@ func casefold(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	ctx.ResultRawText(cases.Fold().Bytes(arg[0].RawText()))
 }
 
+var unaccentPool = sync.Pool{
+	New: func() any {
+		return transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
+	},
+}
+
 func unaccent(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	unaccent := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
+	unaccent := unaccentPool.Get().(transform.Transformer)
+	defer unaccentPool.Put(unaccent)
+
 	res, _, err := transform.Bytes(unaccent, arg[0].RawText())
 	if err != nil {
 		ctx.ResultError(err) // notest
@@ -200,13 +207,16 @@ func normalize(ctx sqlite3.Context, arg ...sqlite3.Value) {
 func regex(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	re, ok := ctx.GetAuxData(0).(*regexp.Regexp)
 	if !ok {
-		r, err := regexp.Compile(arg[0].Text())
-		if err != nil {
-			ctx.ResultError(err)
-			return // notest
+		re, ok = arg[0].Pointer().(*regexp.Regexp)
+		if !ok {
+			r, err := regexp.Compile(arg[0].Text())
+			if err != nil {
+				ctx.ResultError(err)
+				return // notest
+			}
+			re = r
 		}
-		re = r
-		ctx.SetAuxData(0, r)
+		ctx.SetAuxData(0, re)
 	}
 	ctx.ResultBool(re.Match(arg[1].RawText()))
 }

ext/uuid/uuid.go

@@ -17,17 +17,18 @@ import (
 
 // Register registers the SQL functions:
 //
-//	uuid([version], [domain/namespace], [id/data])
-//
-// Generates a UUID as a string.
-//
-//	uuid_str(u)
-//
-// Converts a UUID into a well-formed UUID string.
-//
-//	uuid_blob(u)
-//
-// Converts a UUID into a 16-byte blob.
+//   - uuid([ version [, domain/namespace, [ id/data ]]]):
+//     to generate a UUID as a string
+//   - uuid_str(u):
+//     to convert a UUID into a well-formed UUID string
+//   - uuid_blob(u):
+//     to convert a UUID into a 16-byte blob
+//   - uuid_extract_version(u):
+//     to extract the version of a RFC 4122 UUID
+//   - uuid_extract_timestamp(u):
+//     to extract the timestamp of a version 1/2/6/7 UUID
+//   - gen_random_uuid(u):
+//     to generate a version 4 (random) UUID
 func Register(db *sqlite3.Conn) error {
 	const flags = sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
 	return errors.Join(
@@ -38,7 +39,8 @@ func Register(db *sqlite3.Conn) error {
 		db.CreateFunction("uuid_str", 1, flags, toString),
 		db.CreateFunction("uuid_blob", 1, flags, toBlob),
 		db.CreateFunction("uuid_extract_version", 1, flags, version),
-		db.CreateFunction("uuid_extract_timestamp", 1, flags, timestamp))
+		db.CreateFunction("uuid_extract_timestamp", 1, flags, timestamp),
+		db.CreateFunction("gen_random_uuid", 0, sqlite3.INNOCUOUS, generate))
 }
 
 func generate(ctx sqlite3.Context, arg ...sqlite3.Value) {

func.go

@@ -2,7 +2,10 @@ package sqlite3
 
 import (
 	"context"
+	"io"
+	"iter"
 	"sync"
+	"sync/atomic"
 
 	"github.com/tetratelabs/wazero/api"
 
@@ -44,7 +47,7 @@ func (c Conn) AnyCollationNeeded() error {
 // CreateCollation defines a new collating sequence.
 //
 // https://sqlite.org/c3ref/create_collation.html
-func (c *Conn) CreateCollation(name string, fn func(a, b []byte) int) error {
+func (c *Conn) CreateCollation(name string, fn CollatingFunction) error {
 	var funcPtr ptr_t
 	defer c.arena.mark()()
 	namePtr := c.arena.string(name)
@@ -56,6 +59,10 @@ func (c *Conn) CreateCollation(name string, fn func(a, b []byte) int) error {
 	return c.error(rc)
 }
 
+// Collating function is the type of a collation callback.
+// Implementations must not retain a or b.
+type CollatingFunction func(a, b []byte) int
+
 // CreateFunction defines a new scalar SQL function.
 //
 // https://sqlite.org/c3ref/create_function.html
@@ -76,28 +83,67 @@ func (c *Conn) CreateFunction(name string, nArg int, flag FunctionFlag, fn Scala
 // Implementations must not retain arg.
 type ScalarFunction func(ctx Context, arg ...Value)
 
-// CreateWindowFunction defines a new aggregate or aggregate window SQL function.
-// If fn returns a [WindowFunction], then an aggregate window function is created.
-// If fn returns an [io.Closer], it will be called to free resources.
+// CreateAggregateFunction defines a new aggregate SQL function.
 //
 // https://sqlite.org/c3ref/create_function.html
-func (c *Conn) CreateWindowFunction(name string, nArg int, flag FunctionFlag, fn func() AggregateFunction) error {
+func (c *Conn) CreateAggregateFunction(name string, nArg int, flag FunctionFlag, fn AggregateSeqFunction) error {
 	var funcPtr ptr_t
 	defer c.arena.mark()()
 	namePtr := c.arena.string(name)
 	if fn != nil {
-		funcPtr = util.AddHandle(c.ctx, fn)
+		funcPtr = util.AddHandle(c.ctx, AggregateConstructor(func() AggregateFunction {
+			var a aggregateFunc
+			coro := func(yieldCoro func(struct{}) bool) {
+				seq := func(yieldSeq func([]Value) bool) {
+					for yieldSeq(a.arg) {
+						if !yieldCoro(struct{}{}) {
+							break
+						}
+					}
+				}
+				fn(&a.ctx, seq)
+			}
+			a.next, a.stop = iter.Pull(coro)
+			return &a
+		}))
 	}
-	call := "sqlite3_create_aggregate_function_go"
-	if _, ok := fn().(WindowFunction); ok {
-		call = "sqlite3_create_window_function_go"
-	}
-	rc := res_t(c.call(call,
+	rc := res_t(c.call("sqlite3_create_aggregate_function_go",
 		stk_t(c.handle), stk_t(namePtr), stk_t(nArg),
 		stk_t(flag), stk_t(funcPtr)))
 	return c.error(rc)
 }
 
+// AggregateSeqFunction is the type of an aggregate SQL function.
+// Implementations must not retain the slices yielded by seq.
+type AggregateSeqFunction func(ctx *Context, seq iter.Seq[[]Value])
+
+// CreateWindowFunction defines a new aggregate or aggregate window SQL function.
+// If fn returns a [WindowFunction], an aggregate window function is created.
+// If fn returns an [io.Closer], it will be called to free resources.
+//
+// https://sqlite.org/c3ref/create_function.html
+func (c *Conn) CreateWindowFunction(name string, nArg int, flag FunctionFlag, fn AggregateConstructor) error {
+	var funcPtr ptr_t
+	defer c.arena.mark()()
+	namePtr := c.arena.string(name)
+	if fn != nil {
+		funcPtr = util.AddHandle(c.ctx, AggregateConstructor(func() AggregateFunction {
+			agg := fn()
+			if win, ok := agg.(WindowFunction); ok {
+				return win
+			}
+			return windowFunc{agg, name}
+		}))
+	}
+	rc := res_t(c.call("sqlite3_create_window_function_go",
+		stk_t(c.handle), stk_t(namePtr), stk_t(nArg),
+		stk_t(flag), stk_t(funcPtr)))
+	return c.error(rc)
+}
+
+// AggregateConstructor is a an [AggregateFunction] constructor.
+type AggregateConstructor func() AggregateFunction
+
 // AggregateFunction is the interface an aggregate function should implement.
 //
 // https://sqlite.org/appfunc.html
@@ -146,51 +192,52 @@ func collationCallback(ctx context.Context, mod api.Module, pArg, pDB ptr_t, eTe
 }
 
 func compareCallback(ctx context.Context, mod api.Module, pApp ptr_t, nKey1 int32, pKey1 ptr_t, nKey2 int32, pKey2 ptr_t) uint32 {
-	fn := util.GetHandle(ctx, pApp).(func(a, b []byte) int)
+	fn := util.GetHandle(ctx, pApp).(CollatingFunction)
 	return uint32(fn(util.View(mod, pKey1, int64(nKey1)), util.View(mod, pKey2, int64(nKey2))))
 }
 
 func funcCallback(ctx context.Context, mod api.Module, pCtx, pApp ptr_t, nArg int32, pArg ptr_t) {
-	args := getFuncArgs()
-	defer putFuncArgs(args)
 	db := ctx.Value(connKey{}).(*Conn)
+	args := callbackArgs(db, nArg, pArg)
+	defer returnArgs(args)
 	fn := util.GetHandle(db.ctx, pApp).(ScalarFunction)
-	callbackArgs(db, args[:nArg], pArg)
-	fn(Context{db, pCtx}, args[:nArg]...)
+	fn(Context{db, pCtx}, *args...)
 }
 
 func stepCallback(ctx context.Context, mod api.Module, pCtx, pAgg, pApp ptr_t, nArg int32, pArg ptr_t) {
-	args := getFuncArgs()
-	defer putFuncArgs(args)
 	db := ctx.Value(connKey{}).(*Conn)
-	callbackArgs(db, args[:nArg], pArg)
+	args := callbackArgs(db, nArg, pArg)
+	defer returnArgs(args)
 	fn, _ := callbackAggregate(db, pAgg, pApp)
-	fn.Step(Context{db, pCtx}, args[:nArg]...)
+	fn.Step(Context{db, pCtx}, *args...)
 }
 
-func finalCallback(ctx context.Context, mod api.Module, pCtx, pAgg, pApp ptr_t) {
+func valueCallback(ctx context.Context, mod api.Module, pCtx, pAgg, pApp ptr_t, final int32) {
 	db := ctx.Value(connKey{}).(*Conn)
 	fn, handle := callbackAggregate(db, pAgg, pApp)
 	fn.Value(Context{db, pCtx})
-	if err := util.DelHandle(ctx, handle); err != nil {
-		Context{db, pCtx}.ResultError(err)
-		return // notest
+
+	// Cleanup.
+	if final != 0 {
+		var err error
+		if handle != 0 {
+			err = util.DelHandle(ctx, handle)
+		} else if c, ok := fn.(io.Closer); ok {
+			err = c.Close()
+		}
+		if err != nil {
+			Context{db, pCtx}.ResultError(err)
+			return // notest
+		}
 	}
 }
 
-func valueCallback(ctx context.Context, mod api.Module, pCtx, pAgg ptr_t) {
-	db := ctx.Value(connKey{}).(*Conn)
-	fn := util.GetHandle(db.ctx, pAgg).(AggregateFunction)
-	fn.Value(Context{db, pCtx})
-}
-
 func inverseCallback(ctx context.Context, mod api.Module, pCtx, pAgg ptr_t, nArg int32, pArg ptr_t) {
-	args := getFuncArgs()
-	defer putFuncArgs(args)
 	db := ctx.Value(connKey{}).(*Conn)
-	callbackArgs(db, args[:nArg], pArg)
+	args := callbackArgs(db, nArg, pArg)
+	defer returnArgs(args)
 	fn := util.GetHandle(db.ctx, pAgg).(WindowFunction)
-	fn.Inverse(Context{db, pCtx}, args[:nArg]...)
+	fn.Inverse(Context{db, pCtx}, *args...)
 }
 
 func callbackAggregate(db *Conn, pAgg, pApp ptr_t) (AggregateFunction, ptr_t) {
@@ -200,7 +247,7 @@ func callbackAggregate(db *Conn, pAgg, pApp ptr_t) (AggregateFunction, ptr_t) {
 	}
 
 	// We need to create the aggregate.
-	fn := util.GetHandle(db.ctx, pApp).(func() AggregateFunction)()
+	fn := util.GetHandle(db.ctx, pApp).(AggregateConstructor)()
 	if pAgg != 0 {
 		handle := util.AddHandle(db.ctx, fn)
 		util.Write32(db.mod, pAgg, handle)
@@ -209,25 +256,64 @@ func callbackAggregate(db *Conn, pAgg, pApp ptr_t) (AggregateFunction, ptr_t) {
 	return fn, 0
 }
 
-func callbackArgs(db *Conn, arg []Value, pArg ptr_t) {
-	for i := range arg {
-		arg[i] = Value{
+var (
+	valueArgsPool sync.Pool
+	valueArgsLen  atomic.Int32
+)
+
+func callbackArgs(db *Conn, nArg int32, pArg ptr_t) *[]Value {
+	arg, ok := valueArgsPool.Get().(*[]Value)
+	if !ok || cap(*arg) < int(nArg) {
+		max := valueArgsLen.Or(nArg) | nArg
+		lst := make([]Value, max)
+		arg = &lst
+	}
+	lst := (*arg)[:nArg]
+	for i := range lst {
+		lst[i] = Value{
 			c:      db,
 			handle: util.Read32[ptr_t](db.mod, pArg+ptr_t(i)*ptrlen),
 		}
 	}
+	*arg = lst
+	return arg
 }
 
-var funcArgsPool sync.Pool
-
-func putFuncArgs(p *[_MAX_FUNCTION_ARG]Value) {
-	funcArgsPool.Put(p)
+func returnArgs(p *[]Value) {
+	valueArgsPool.Put(p)
 }
 
-func getFuncArgs() *[_MAX_FUNCTION_ARG]Value {
-	if p := funcArgsPool.Get(); p == nil {
-		return new([_MAX_FUNCTION_ARG]Value)
-	} else {
-		return p.(*[_MAX_FUNCTION_ARG]Value)
+type aggregateFunc struct {
+	next func() (struct{}, bool)
+	stop func()
+	ctx  Context
+	arg  []Value
+}
+
+func (a *aggregateFunc) Step(ctx Context, arg ...Value) {
+	a.ctx = ctx
+	a.arg = append(a.arg[:0], arg...)
+	if _, more := a.next(); !more {
+		a.stop()
 	}
 }
+
+func (a *aggregateFunc) Value(ctx Context) {
+	a.ctx = ctx
+	a.stop()
+}
+
+func (a *aggregateFunc) Close() error {
+	a.stop()
+	return nil
+}
+
+type windowFunc struct {
+	AggregateFunction
+	name string
+}
+
+func (w windowFunc) Inverse(ctx Context, arg ...Value) {
+	// Implementing inverse allows certain queries that don't really need it to succeed.
+	ctx.ResultError(util.ErrorString(w.name + ": may not be used as a window function"))
+}

func_seq_test.go

@@ -0,0 +1,57 @@
+package sqlite3_test
+
+import (
+	"fmt"
+	"iter"
+	"log"
+
+	"github.com/ncruces/go-sqlite3"
+	_ "github.com/ncruces/go-sqlite3/embed"
+)
+
+func ExampleConn_CreateAggregateFunction() {
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Exec(`CREATE TABLE test (col)`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = db.Exec(`INSERT INTO test VALUES (1), (2), (3)`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = db.CreateAggregateFunction("seq_avg", 1, sqlite3.DETERMINISTIC|sqlite3.INNOCUOUS,
+		func(ctx *sqlite3.Context, seq iter.Seq[[]sqlite3.Value]) {
+			count := 0
+			total := 0.0
+			for arg := range seq {
+				total += arg[0].Float()
+				count++
+			}
+			ctx.ResultFloat(total / float64(count))
+		})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT seq_avg(col) FROM test`)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer stmt.Close()
+
+	for stmt.Step() {
+		fmt.Println(stmt.ColumnFloat(0))
+	}
+	if err := stmt.Err(); err != nil {
+		log.Fatal(err)
+	}
+	// Output:
+	// 2
+}

go.mod

@@ -1,6 +1,6 @@
 module github.com/ncruces/go-sqlite3
 
-go 1.22.0
+go 1.23.0
 
 toolchain go1.24.0
 
@@ -8,17 +8,20 @@ require (
 	github.com/ncruces/julianday v1.0.0
 	github.com/ncruces/sort v0.1.5
 	github.com/tetratelabs/wazero v1.9.0
-	golang.org/x/crypto v0.33.0
-	golang.org/x/sys v0.30.0
+	golang.org/x/crypto v0.36.0
+	golang.org/x/sys v0.31.0
 )
 
 require (
 	github.com/dchest/siphash v1.2.3 // ext/bloom
 	github.com/google/uuid v1.6.0 // ext/uuid
 	github.com/psanford/httpreadat v0.1.0 // example
-	golang.org/x/sync v0.11.0 // test
-	golang.org/x/text v0.22.0 // ext/unicode
+	golang.org/x/sync v0.12.0 // test
+	golang.org/x/text v0.23.0 // ext/unicode
 	lukechampine.com/adiantum v1.1.1 // vfs/adiantum
 )
 
-retract v0.4.0 // tagged from the wrong branch
+retract (
+	v0.23.2 // tagged from the wrong branch
+	v0.4.0 // tagged from the wrong branch
+)

go.sum

@@ -10,13 +10,13 @@ github.com/psanford/httpreadat v0.1.0 h1:VleW1HS2zO7/4c7c7zNl33fO6oYACSagjJIyMIw
 github.com/psanford/httpreadat v0.1.0/go.mod h1:Zg7P+TlBm3bYbyHTKv/EdtSJZn3qwbPwpfZ/I9GKCRE=
 github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
 github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
-golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
-golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
-golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
-golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
-golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
-golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
+golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
+golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
+golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw=
+golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
+golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
+golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
 lukechampine.com/adiantum v1.1.1 h1:4fp6gTxWCqpEbLy40ExiYDDED3oUNWx5cTqBCtPdZqA=
 lukechampine.com/adiantum v1.1.1/go.mod h1:LrAYVnTYLnUtE/yMp5bQr0HstAf060YUF8nM0B6+rUw=

gormlite/go.mod

@@ -1,11 +1,11 @@
 module github.com/ncruces/go-sqlite3/gormlite
 
-go 1.22.0
+go 1.23.0
 
 toolchain go1.24.0
 
 require (
-	github.com/ncruces/go-sqlite3 v0.23.0
+	github.com/ncruces/go-sqlite3 v0.24.0
 	gorm.io/gorm v1.25.12
 )
 
@@ -13,7 +13,7 @@ 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.8.2 // indirect
+	github.com/tetratelabs/wazero v1.9.0 // indirect
 	golang.org/x/sys v0.30.0 // indirect
 	golang.org/x/text v0.22.0 // indirect
 )

gormlite/go.sum

@@ -2,12 +2,12 @@ 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.23.0 h1:90j/ar8Ywu2AtsfDl5WhO9sgP/rNk76BcKGIzAHO8AQ=
-github.com/ncruces/go-sqlite3 v0.23.0/go.mod h1:gq2nriHSczOs11SqGW5+0X+SgLdkdj4K+j4F/AhQ+8g=
+github.com/ncruces/go-sqlite3 v0.24.0 h1:Z4jfmzu2NCd4SmyFwLT2OmF3EnTZbqwATvdiuNHNhLA=
+github.com/ncruces/go-sqlite3 v0.24.0/go.mod h1:/Vs8ACZHjJ1SA6E9RZUn3EyB1OP3nDQ4z/ar+0fplTQ=
 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.8.2 h1:yIgLR/b2bN31bjxwXHD8a3d+BogigR952csSDdLYEv4=
-github.com/tetratelabs/wazero v1.8.2/go.mod h1:yAI0XTsMBhREkM/YDAK/zNou3GoiAce1P6+rp/wQhjs=
+github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
+github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
 golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
 golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=

internal/util/error.go

@@ -75,7 +75,7 @@ func ErrorCodeString(rc uint32) string {
 		return "sqlite3: unable to open database file"
 	case PROTOCOL:
 		return "sqlite3: locking protocol"
-	case FORMAT:
+	case EMPTY:
 		break
 	case SCHEMA:
 		return "sqlite3: database schema has changed"
@@ -91,7 +91,7 @@ func ErrorCodeString(rc uint32) string {
 		break
 	case AUTH:
 		return "sqlite3: authorization denied"
-	case EMPTY:
+	case FORMAT:
 		break
 	case RANGE:
 		return "sqlite3: column index out of range"

internal/util/mem.go

@@ -135,11 +135,10 @@ func ReadString(mod api.Module, ptr Ptr_t, maxlen int64) string {
 			panic(RangeErr)
 		}
 	}
-	if i := bytes.IndexByte(buf, 0); i < 0 {
-		panic(NoNulErr)
-	} else {
+	if i := bytes.IndexByte(buf, 0); i >= 0 {
 		return string(buf[:i])
 	}
+	panic(NoNulErr)
 }
 
 func WriteBytes(mod api.Module, ptr Ptr_t, b []byte) {

sqlite.go

@@ -120,33 +120,33 @@ func (sqlt *sqlite) error(rc res_t, handle ptr_t, sql ...string) error {
 		return nil
 	}
 
-	err := Error{code: rc}
-
-	if err.Code() == NOMEM || err.ExtendedCode() == IOERR_NOMEM {
+	if ErrorCode(rc) == NOMEM || xErrorCode(rc) == IOERR_NOMEM {
 		panic(util.OOMErr)
 	}
 
-	if ptr := ptr_t(sqlt.call("sqlite3_errstr", stk_t(rc))); ptr != 0 {
-		err.str = util.ReadString(sqlt.mod, ptr, _MAX_NAME)
-	}
-
 	if handle != 0 {
+		var msg, query string
 		if ptr := ptr_t(sqlt.call("sqlite3_errmsg", stk_t(handle))); ptr != 0 {
-			err.msg = util.ReadString(sqlt.mod, ptr, _MAX_LENGTH)
+			msg = util.ReadString(sqlt.mod, ptr, _MAX_LENGTH)
+			switch {
+			case msg == "not an error":
+				msg = ""
+			case msg == util.ErrorCodeString(uint32(rc))[len("sqlite3: "):]:
+				msg = ""
+			}
 		}
 
 		if len(sql) != 0 {
 			if i := int32(sqlt.call("sqlite3_error_offset", stk_t(handle))); i != -1 {
-				err.sql = sql[0][i:]
+				query = sql[0][i:]
 			}
 		}
-	}
 
-	switch err.msg {
-	case err.str, "not an error":
-		err.msg = ""
+		if msg != "" || query != "" {
+			return &Error{code: rc, msg: msg, sql: query}
+		}
 	}
-	return &err
+	return xErrorCode(rc)
 }
 
 func (sqlt *sqlite) getfn(name string) api.Function {
@@ -212,14 +212,10 @@ func (sqlt *sqlite) realloc(ptr ptr_t, size int64) ptr_t {
 }
 
 func (sqlt *sqlite) newBytes(b []byte) ptr_t {
-	if (*[0]byte)(b) == nil {
+	if len(b) == 0 {
 		return 0
 	}
-	size := len(b)
-	if size == 0 {
-		size = 1
-	}
-	ptr := sqlt.new(int64(size))
+	ptr := sqlt.new(int64(len(b)))
 	util.WriteBytes(sqlt.mod, ptr, b)
 	return ptr
 }
@@ -288,7 +284,7 @@ func (a *arena) new(size int64) ptr_t {
 }
 
 func (a *arena) bytes(b []byte) ptr_t {
-	if (*[0]byte)(b) == nil {
+	if len(b) == 0 {
 		return 0
 	}
 	ptr := a.new(int64(len(b)))
@@ -317,8 +313,7 @@ func exportCallbacks(env wazero.HostModuleBuilder) wazero.HostModuleBuilder {
 	util.ExportFuncVI(env, "go_destroy", destroyCallback)
 	util.ExportFuncVIIII(env, "go_func", funcCallback)
 	util.ExportFuncVIIIII(env, "go_step", stepCallback)
-	util.ExportFuncVIII(env, "go_final", finalCallback)
-	util.ExportFuncVII(env, "go_value", valueCallback)
+	util.ExportFuncVIIII(env, "go_value", valueCallback)
 	util.ExportFuncVIIII(env, "go_inverse", inverseCallback)
 	util.ExportFuncVIIII(env, "go_collation_needed", collationCallback)
 	util.ExportFuncIIIIII(env, "go_compare", compareCallback)

sqlite3/func.c

@@ -11,9 +11,8 @@ int go_compare(go_handle, int, const void *, int, const void *);
 void go_func(sqlite3_context *, go_handle, int, sqlite3_value **);
 
 void go_step(sqlite3_context *, go_handle *, go_handle, int, sqlite3_value **);
-void go_final(sqlite3_context *, go_handle, go_handle);
-void go_value(sqlite3_context *, go_handle);
-void go_inverse(sqlite3_context *, go_handle *, int, sqlite3_value **);
+void go_value(sqlite3_context *, go_handle *, go_handle, bool);
+void go_inverse(sqlite3_context *, go_handle, int, sqlite3_value **);
 
 void go_func_wrapper(sqlite3_context *ctx, int nArg, sqlite3_value **pArg) {
   go_func(ctx, sqlite3_user_data(ctx), nArg, pArg);
@@ -28,22 +27,26 @@ void go_step_wrapper(sqlite3_context *ctx, int nArg, sqlite3_value **pArg) {
   go_step(ctx, agg, data, nArg, pArg);
 }
 
+void go_value_wrapper(sqlite3_context *ctx) {
+  go_handle *agg = sqlite3_aggregate_context(ctx, 4);
+  go_handle data = NULL;
+  if (agg == NULL || *agg == NULL) {
+    data = sqlite3_user_data(ctx);
+  }
+  go_value(ctx, agg, data, /*final=*/false);
+}
+
 void go_final_wrapper(sqlite3_context *ctx) {
   go_handle *agg = sqlite3_aggregate_context(ctx, 0);
   go_handle data = NULL;
   if (agg == NULL || *agg == NULL) {
     data = sqlite3_user_data(ctx);
   }
-  go_final(ctx, agg, data);
-}
-
-void go_value_wrapper(sqlite3_context *ctx) {
-  go_handle *agg = sqlite3_aggregate_context(ctx, 4);
-  go_value(ctx, *agg);
+  go_value(ctx, agg, data, /*final=*/true);
 }
 
 void go_inverse_wrapper(sqlite3_context *ctx, int nArg, sqlite3_value **pArg) {
-  go_handle *agg = sqlite3_aggregate_context(ctx, 4);
+  go_handle *agg = sqlite3_aggregate_context(ctx, 0);
   go_inverse(ctx, *agg, nArg, pArg);
 }
 

sqlite3/hooks.c

@@ -19,6 +19,10 @@ void go_log(void *, int, const char *);
 unsigned int go_autovacuum_pages(void *, const char *, unsigned int,
                                  unsigned int, unsigned int);
 
+void sqlite3_log_go(int iErrCode, const char *zMsg) {
+  sqlite3_log(iErrCode, "%s", zMsg);
+}
+
 void sqlite3_progress_handler_go(sqlite3 *db, int n) {
   sqlite3_progress_handler(db, n, go_progress_handler, /*arg=*/NULL);
 }

sqlite3/sqlite_opt.h

@@ -16,6 +16,9 @@
 // #define SQLITE_OMIT_DECLTYPE
 // #define SQLITE_OMIT_PROGRESS_CALLBACK
 
+// TODO add this:
+// #define SQLITE_ENABLE_API_ARMOR
+
 // Other Options
 
 #define SQLITE_ALLOW_URI_AUTHORITY

sqlite_test.go

@@ -125,11 +125,6 @@ func Test_sqlite_newBytes(t *testing.T) {
 	if got := util.View(sqlite.mod, ptr, int64(len(want))); !bytes.Equal(got, want) {
 		t.Errorf("got %q, want %q", got, want)
 	}
-
-	ptr = sqlite.newBytes(buf[:0])
-	if ptr == 0 {
-		t.Fatal("got nullptr, want a pointer")
-	}
 }
 
 func Test_sqlite_newString(t *testing.T) {

stmt.go

@@ -106,7 +106,14 @@ func (s *Stmt) Busy() bool {
 //
 // https://sqlite.org/c3ref/step.html
 func (s *Stmt) Step() bool {
-	s.c.checkInterrupt(s.c.handle)
+	if s.c.interrupt.Err() != nil {
+		s.err = INTERRUPT
+		return false
+	}
+	return s.step()
+}
+
+func (s *Stmt) step() bool {
 	rc := res_t(s.c.call("sqlite3_step", stk_t(s.handle)))
 	switch rc {
 	case _ROW:
@@ -131,7 +138,11 @@ func (s *Stmt) Err() error {
 // Exec is a convenience function that repeatedly calls [Stmt.Step] until it returns false,
 // then calls [Stmt.Reset] to reset the statement and get any error that occurred.
 func (s *Stmt) Exec() error {
-	for s.Step() {
+	if s.c.interrupt.Err() != nil {
+		return INTERRUPT
+	}
+	// TODO: implement this in C.
+	for s.step() {
 	}
 	return s.Reset()
 }
@@ -254,13 +265,15 @@ func (s *Stmt) BindText(param int, value string) error {
 
 // BindRawText binds a []byte to the prepared statement as text.
 // The leftmost SQL parameter has an index of 1.
-// Binding a nil slice is the same as calling [Stmt.BindNull].
 //
 // https://sqlite.org/c3ref/bind_blob.html
 func (s *Stmt) BindRawText(param int, value []byte) error {
 	if len(value) > _MAX_LENGTH {
 		return TOOBIG
 	}
+	if len(value) == 0 {
+		return s.BindText(param, "")
+	}
 	ptr := s.c.newBytes(value)
 	rc := res_t(s.c.call("sqlite3_bind_text_go",
 		stk_t(s.handle), stk_t(param),
@@ -270,13 +283,15 @@ func (s *Stmt) BindRawText(param int, value []byte) error {
 
 // BindBlob binds a []byte to the prepared statement.
 // The leftmost SQL parameter has an index of 1.
-// Binding a nil slice is the same as calling [Stmt.BindNull].
 //
 // https://sqlite.org/c3ref/bind_blob.html
 func (s *Stmt) BindBlob(param int, value []byte) error {
 	if len(value) > _MAX_LENGTH {
 		return TOOBIG
 	}
+	if len(value) == 0 {
+		return s.BindZeroBlob(param, 0)
+	}
 	ptr := s.c.newBytes(value)
 	rc := res_t(s.c.call("sqlite3_bind_blob_go",
 		stk_t(s.handle), stk_t(param),
@@ -560,7 +575,7 @@ func (s *Stmt) ColumnBlob(col int, buf []byte) []byte {
 func (s *Stmt) ColumnRawText(col int) []byte {
 	ptr := ptr_t(s.c.call("sqlite3_column_text",
 		stk_t(s.handle), stk_t(col)))
-	return s.columnRawBytes(col, ptr)
+	return s.columnRawBytes(col, ptr, 1)
 }
 
 // ColumnRawBlob returns the value of the result column as a []byte.
@@ -572,10 +587,10 @@ func (s *Stmt) ColumnRawText(col int) []byte {
 func (s *Stmt) ColumnRawBlob(col int) []byte {
 	ptr := ptr_t(s.c.call("sqlite3_column_blob",
 		stk_t(s.handle), stk_t(col)))
-	return s.columnRawBytes(col, ptr)
+	return s.columnRawBytes(col, ptr, 0)
 }
 
-func (s *Stmt) columnRawBytes(col int, ptr ptr_t) []byte {
+func (s *Stmt) columnRawBytes(col int, ptr ptr_t, nul int32) []byte {
 	if ptr == 0 {
 		rc := res_t(s.c.call("sqlite3_errcode", stk_t(s.c.handle)))
 		if rc != _ROW && rc != _DONE {
@@ -586,7 +601,7 @@ func (s *Stmt) columnRawBytes(col int, ptr ptr_t) []byte {
 
 	n := int32(s.c.call("sqlite3_column_bytes",
 		stk_t(s.handle), stk_t(col)))
-	return util.View(s.c.mod, ptr, int64(n))
+	return util.View(s.c.mod, ptr, int64(n+nul))[:n]
 }
 
 // ColumnJSON parses the JSON-encoded value of the result column
@@ -633,22 +648,12 @@ func (s *Stmt) ColumnValue(col int) Value {
 // [INTEGER] columns will be retrieved as int64 values,
 // [FLOAT] as float64, [NULL] as nil,
 // [TEXT] as string, and [BLOB] as []byte.
-// Any []byte are owned by SQLite and may be invalidated by
-// subsequent calls to [Stmt] methods.
 func (s *Stmt) Columns(dest ...any) error {
-	defer s.c.arena.mark()()
-	count := int64(len(dest))
-	typePtr := s.c.arena.new(count)
-	dataPtr := s.c.arena.new(count * 8)
-
-	rc := res_t(s.c.call("sqlite3_columns_go",
-		stk_t(s.handle), stk_t(count), stk_t(typePtr), stk_t(dataPtr)))
-	if err := s.c.error(rc); err != nil {
+	types, ptr, err := s.columns(int64(len(dest)))
+	if err != nil {
 		return err
 	}
 
-	types := util.View(s.c.mod, typePtr, count)
-
 	// Avoid bounds checks on types below.
 	if len(types) != len(dest) {
 		panic(util.AssertErr())
@@ -657,26 +662,95 @@ func (s *Stmt) Columns(dest ...any) error {
 	for i := range dest {
 		switch types[i] {
 		case byte(INTEGER):
-			dest[i] = util.Read64[int64](s.c.mod, dataPtr)
+			dest[i] = util.Read64[int64](s.c.mod, ptr)
 		case byte(FLOAT):
-			dest[i] = util.ReadFloat64(s.c.mod, dataPtr)
+			dest[i] = util.ReadFloat64(s.c.mod, ptr)
 		case byte(NULL):
 			dest[i] = nil
-		default:
-			ptr := util.Read32[ptr_t](s.c.mod, dataPtr+0)
-			if ptr == 0 {
-				dest[i] = []byte{}
-				continue
-			}
-			len := util.Read32[int32](s.c.mod, dataPtr+4)
-			buf := util.View(s.c.mod, ptr, int64(len))
-			if types[i] == byte(TEXT) {
+		case byte(TEXT):
+			len := util.Read32[int32](s.c.mod, ptr+4)
+			if len != 0 {
+				ptr := util.Read32[ptr_t](s.c.mod, ptr)
+				buf := util.View(s.c.mod, ptr, int64(len))
 				dest[i] = string(buf)
 			} else {
-				dest[i] = buf
+				dest[i] = ""
+			}
+		case byte(BLOB):
+			len := util.Read32[int32](s.c.mod, ptr+4)
+			if len != 0 {
+				ptr := util.Read32[ptr_t](s.c.mod, ptr)
+				buf := util.View(s.c.mod, ptr, int64(len))
+				tmp, _ := dest[i].([]byte)
+				dest[i] = append(tmp[:0], buf...)
+			} else {
+				dest[i], _ = dest[i].([]byte)
 			}
 		}
-		dataPtr += 8
+		ptr += 8
 	}
 	return nil
 }
+
+// ColumnsRaw populates result columns into the provided slice.
+// The slice must have [Stmt.ColumnCount] length.
+//
+// [INTEGER] columns will be retrieved as int64 values,
+// [FLOAT] as float64, [NULL] as nil,
+// [TEXT] and [BLOB] as []byte.
+// Any []byte are owned by SQLite and may be invalidated by
+// subsequent calls to [Stmt] methods.
+func (s *Stmt) ColumnsRaw(dest ...any) error {
+	types, ptr, err := s.columns(int64(len(dest)))
+	if err != nil {
+		return err
+	}
+
+	// Avoid bounds checks on types below.
+	if len(types) != len(dest) {
+		panic(util.AssertErr())
+	}
+
+	for i := range dest {
+		switch types[i] {
+		case byte(INTEGER):
+			dest[i] = util.Read64[int64](s.c.mod, ptr)
+		case byte(FLOAT):
+			dest[i] = util.ReadFloat64(s.c.mod, ptr)
+		case byte(NULL):
+			dest[i] = nil
+		default:
+			len := util.Read32[int32](s.c.mod, ptr+4)
+			if len == 0 && types[i] == byte(BLOB) {
+				dest[i] = []byte{}
+			} else {
+				cap := len
+				if types[i] == byte(TEXT) {
+					cap++
+				}
+				ptr := util.Read32[ptr_t](s.c.mod, ptr)
+				buf := util.View(s.c.mod, ptr, int64(cap))[:len]
+				dest[i] = buf
+			}
+		}
+		ptr += 8
+	}
+	return nil
+}
+
+func (s *Stmt) columns(count int64) ([]byte, ptr_t, error) {
+	defer s.c.arena.mark()()
+	typePtr := s.c.arena.new(count)
+	dataPtr := s.c.arena.new(count * 8)
+
+	rc := res_t(s.c.call("sqlite3_columns_go",
+		stk_t(s.handle), stk_t(count), stk_t(typePtr), stk_t(dataPtr)))
+	if rc == res_t(MISUSE) {
+		return nil, 0, MISUSE
+	}
+	if err := s.c.error(rc); err != nil {
+		return nil, 0, err
+	}
+
+	return util.View(s.c.mod, typePtr, count), dataPtr, nil
+}

tests/conn_test.go

@@ -146,10 +146,7 @@ func TestConn_SetInterrupt(t *testing.T) {
 	}
 	defer stmt.Close()
 
-	go func() {
-		time.Sleep(time.Millisecond)
-		cancel()
-	}()
+	time.AfterFunc(time.Millisecond, cancel)
 
 	// Interrupting works.
 	err = stmt.Exec()

tests/parallel/parallel_test.go

@@ -1,8 +1,7 @@
 package tests
 
 import (
-	"context"
-	"errors"
+	"fmt"
 	"io"
 	"log"
 	"net/url"
@@ -10,7 +9,6 @@ import (
 	"os/exec"
 	"path/filepath"
 	"testing"
-	"time"
 
 	"golang.org/x/sync/errgroup"
 
@@ -24,15 +22,18 @@ import (
 )
 
 func TestMain(m *testing.M) {
-	sqlite3.AutoExtension(func(c *sqlite3.Conn) error {
-		return c.ConfigLog(func(code sqlite3.ExtendedErrorCode, msg string) {
-			// Having to do journal recovery is unexpected.
-			if errors.Is(code, sqlite3.NOTICE) {
-				log.Panicf("%v (%d): %s", code, code, msg)
-			} else {
-				log.Printf("%v (%d): %s", code, code, msg)
-			}
-		})
+	sqlite3.Initialize()
+	sqlite3.ConfigLog(func(code sqlite3.ExtendedErrorCode, msg string) {
+		switch code {
+		case sqlite3.NOTICE_RECOVER_WAL:
+			// Wal "recovery" is expected.
+			break
+		case sqlite3.NOTICE_RECOVER_ROLLBACK:
+			// Rollback journal recovery is an error.
+			log.Panicf("%v (%d): %s", code, code, msg)
+		default:
+			log.Printf("%v (%d): %s", code, code, msg)
+		}
 	})
 	m.Run()
 }
@@ -54,6 +55,7 @@ func Test_parallel(t *testing.T) {
 		"?_pragma=busy_timeout(10000)" +
 		"&_pragma=journal_mode(truncate)" +
 		"&_pragma=synchronous(off)"
+	createDB(t, name)
 	testParallel(t, name, iter)
 	testIntegrity(t, name)
 }
@@ -67,7 +69,7 @@ func Test_wal(t *testing.T) {
 	if testing.Short() {
 		iter = 1000
 	} else {
-		iter = 2500
+		iter = 5000
 	}
 
 	name := "file:" +
@@ -75,6 +77,7 @@ func Test_wal(t *testing.T) {
 		"?_pragma=busy_timeout(10000)" +
 		"&_pragma=journal_mode(wal)" +
 		"&_pragma=synchronous(off)"
+	createDB(t, name)
 	testParallel(t, name, iter)
 	testIntegrity(t, name)
 }
@@ -90,6 +93,7 @@ func Test_memdb(t *testing.T) {
 	name := memdb.TestDB(t, url.Values{
 		"_pragma": {"busy_timeout(10000)"},
 	})
+	createDB(t, name)
 	testParallel(t, name, iter)
 	testIntegrity(t, name)
 }
@@ -113,6 +117,7 @@ func Test_adiantum(t *testing.T) {
 		"&_pragma=busy_timeout(10000)" +
 		"&_pragma=journal_mode(truncate)" +
 		"&_pragma=synchronous(off)"
+	createDB(t, name)
 	testParallel(t, name, iter)
 	testIntegrity(t, name)
 }
@@ -136,6 +141,7 @@ func Test_xts(t *testing.T) {
 		"&_pragma=busy_timeout(10000)" +
 		"&_pragma=journal_mode(truncate)" +
 		"&_pragma=synchronous(off)"
+	createDB(t, name)
 	testParallel(t, name, iter)
 	testIntegrity(t, name)
 }
@@ -155,14 +161,17 @@ func Test_MultiProcess_rollback(t *testing.T) {
 		"?_pragma=busy_timeout(10000)" +
 		"&_pragma=journal_mode(truncate)" +
 		"&_pragma=synchronous(off)"
+	createDB(t, name)
 
 	exe, err := os.Executable()
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	cmd := exec.Command(exe, append(os.Args[1:], "-test.v", "-test.run=Test_ChildProcess_rollback")...)
+	cmd := exec.Command(exe, append(os.Args[1:],
+		"-test.v", "-test.count=1", "-test.run=Test_ChildProcess_rollback")...)
 	out, err := cmd.StdoutPipe()
+	cmd.Stderr = os.Stderr
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -214,14 +223,17 @@ func Test_MultiProcess_wal(t *testing.T) {
 		"?_pragma=busy_timeout(10000)" +
 		"&_pragma=journal_mode(wal)" +
 		"&_pragma=synchronous(off)"
+	createDB(t, name)
 
 	exe, err := os.Executable()
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	cmd := exec.Command(exe, append(os.Args[1:], "-test.v", "-test.run=Test_ChildProcess_wal")...)
+	cmd := exec.Command(exe, append(os.Args[1:],
+		"-test.v", "-test.count=1", "-test.run=Test_ChildProcess_wal")...)
 	out, err := cmd.StdoutPipe()
+	cmd.Stderr = os.Stderr
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -263,14 +275,14 @@ func Benchmark_parallel(b *testing.B) {
 		b.Skip("skipping without shared memory")
 	}
 
-	sqlite3.Initialize()
-	b.ResetTimer()
-
 	name := "file:" +
 		filepath.Join(b.TempDir(), "test.db") +
 		"?_pragma=busy_timeout(10000)" +
 		"&_pragma=journal_mode(truncate)" +
 		"&_pragma=synchronous(off)"
+	createDB(b, name)
+
+	b.ResetTimer()
 	testParallel(b, name, b.N)
 }
 
@@ -279,55 +291,51 @@ func Benchmark_wal(b *testing.B) {
 		b.Skip("skipping without shared memory")
 	}
 
-	sqlite3.Initialize()
-	b.ResetTimer()
-
 	name := "file:" +
 		filepath.Join(b.TempDir(), "test.db") +
 		"?_pragma=busy_timeout(10000)" +
 		"&_pragma=journal_mode(wal)" +
 		"&_pragma=synchronous(off)"
+	createDB(b, name)
+
+	b.ResetTimer()
 	testParallel(b, name, b.N)
 }
 
 func Benchmark_memdb(b *testing.B) {
-	sqlite3.Initialize()
-	b.ResetTimer()
-
 	name := memdb.TestDB(b, url.Values{
 		"_pragma": {"busy_timeout(10000)"},
 	})
+	createDB(b, name)
+
+	b.ResetTimer()
 	testParallel(b, name, b.N)
 }
 
+func createDB(t testing.TB, name string) {
+	db, err := sqlite3.Open(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Exec(`CREATE TABLE IF NOT EXISTS users (id INT, name VARCHAR(10))`)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
 func testParallel(t testing.TB, name string, n int) {
 	writer := func() error {
 		db, err := sqlite3.Open(name)
 		if err != nil {
-			return err
+			return fmt.Errorf("writer: open: %w", err)
 		}
 		defer db.Close()
 
-		err = db.BusyHandler(func(ctx context.Context, count int) (retry bool) {
-			select {
-			case <-time.After(time.Millisecond):
-				return true
-			case <-ctx.Done():
-				return false
-			}
-		})
-		if err != nil {
-			return err
-		}
-
-		err = db.Exec(`CREATE TABLE IF NOT EXISTS users (id INT, name VARCHAR(10))`)
-		if err != nil {
-			return err
-		}
-
 		err = db.Exec(`INSERT INTO users (id, name) VALUES (0, 'go'), (1, 'zig'), (2, 'whatever')`)
 		if err != nil {
-			return err
+			return fmt.Errorf("writer: insert: %w", err)
 		}
 
 		return db.Close()
@@ -336,13 +344,13 @@ func testParallel(t testing.TB, name string, n int) {
 	reader := func() error {
 		db, err := sqlite3.Open(name)
 		if err != nil {
-			return err
+			return fmt.Errorf("reader: open: %w", err)
 		}
 		defer db.Close()
 
 		stmt, _, err := db.Prepare(`SELECT id, name FROM users`)
 		if err != nil {
-			return err
+			return fmt.Errorf("reader: select: %w", err)
 		}
 		defer stmt.Close()
 
@@ -351,15 +359,15 @@ func testParallel(t testing.TB, name string, n int) {
 			row++
 		}
 		if err := stmt.Err(); err != nil {
-			return err
+			return fmt.Errorf("reader: step: %w", err)
 		}
 		if row%3 != 0 {
-			t.Errorf("got %d rows, want multiple of 3", row)
+			return fmt.Errorf("reader: got %d rows, want multiple of 3", row)
 		}
 
 		err = stmt.Close()
 		if err != nil {
-			return err
+			return fmt.Errorf("reader: close: %w", err)
 		}
 
 		return db.Close()

tests/stmt_test.go

@@ -89,6 +89,13 @@ func TestStmt(t *testing.T) {
 		t.Fatal(err)
 	}
 
+	if err := stmt.BindRawText(1, nil); err != nil {
+		t.Fatal(err)
+	}
+	if err := stmt.Exec(); err != nil {
+		t.Fatal(err)
+	}
+
 	if err := stmt.BindBlob(1, []byte("")); err != nil {
 		t.Fatal(err)
 	}
@@ -103,13 +110,6 @@ func TestStmt(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if err := stmt.BindBlob(1, nil); err != nil {
-		t.Fatal(err)
-	}
-	if err := stmt.Exec(); err != nil {
-		t.Fatal(err)
-	}
-
 	if err := stmt.BindZeroBlob(1, 4); err != nil {
 		t.Fatal(err)
 	}
@@ -353,6 +353,31 @@ func TestStmt(t *testing.T) {
 		}
 	}
 
+	if stmt.Step() {
+		if got := stmt.ColumnType(0); got != sqlite3.TEXT {
+			t.Errorf("got %v, want TEXT", got)
+		}
+		if got := stmt.ColumnBool(0); got != false {
+			t.Errorf("got %v, want false", got)
+		}
+		if got := stmt.ColumnInt(0); got != 0 {
+			t.Errorf("got %v, want zero", got)
+		}
+		if got := stmt.ColumnFloat(0); got != 0 {
+			t.Errorf("got %v, want zero", got)
+		}
+		if got := stmt.ColumnText(0); got != "" {
+			t.Errorf("got %q, want empty", got)
+		}
+		if got := stmt.ColumnBlob(0, nil); got != nil {
+			t.Errorf("got %q, want nil", got)
+		}
+		var got any
+		if err := stmt.ColumnJSON(0, &got); err == nil {
+			t.Errorf("got %v, want error", got)
+		}
+	}
+
 	if stmt.Step() {
 		if got := stmt.ColumnType(0); got != sqlite3.BLOB {
 			t.Errorf("got %v, want BLOB", got)
@@ -403,33 +428,6 @@ func TestStmt(t *testing.T) {
 		}
 	}
 
-	if stmt.Step() {
-		if got := stmt.ColumnType(0); got != sqlite3.NULL {
-			t.Errorf("got %v, want NULL", got)
-		}
-		if got := stmt.ColumnBool(0); got != false {
-			t.Errorf("got %v, want false", got)
-		}
-		if got := stmt.ColumnInt(0); got != 0 {
-			t.Errorf("got %v, want zero", got)
-		}
-		if got := stmt.ColumnFloat(0); got != 0 {
-			t.Errorf("got %v, want zero", got)
-		}
-		if got := stmt.ColumnText(0); got != "" {
-			t.Errorf("got %q, want empty", got)
-		}
-		if got := stmt.ColumnBlob(0, nil); got != nil {
-			t.Errorf("got %q, want nil", got)
-		}
-		var got any = 1
-		if err := stmt.ColumnJSON(0, &got); err != nil {
-			t.Error(err)
-		} else if got != nil {
-			t.Errorf("got %v, want NULL", got)
-		}
-	}
-
 	if stmt.Step() {
 		if got := stmt.ColumnType(0); got != sqlite3.BLOB {
 			t.Errorf("got %v, want BLOB", got)
@@ -664,6 +662,42 @@ func TestStmt_ColumnValue(t *testing.T) {
 	}
 }
 
+func TestStmt_Columns(t *testing.T) {
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	stmt, _, err := db.Prepare(`SELECT 0, 0.5, 'abc', x'cafe', NULL`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer stmt.Close()
+
+	if stmt.Step() {
+		var dest [5]any
+		if err := stmt.Columns(dest[:]...); err != nil {
+			t.Fatal(err)
+		}
+		if got := dest[0]; got != int64(0) {
+			t.Errorf("got %d, want 0", got)
+		}
+		if got := dest[1]; got != float64(0.5) {
+			t.Errorf("got %f, want 0.5", got)
+		}
+		if got := dest[2]; got != "abc" {
+			t.Errorf("got %q, want 'abc'", got)
+		}
+		if got := dest[3]; string(got.([]byte)) != "\xCA\xFE" {
+			t.Errorf("got %q, want x'cafe'", got)
+		}
+		if got := dest[4]; got != nil {
+			t.Errorf("got %q, want nil", got)
+		}
+	}
+}
+
 func TestStmt_Error(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping in short mode")

txn.go

@@ -2,7 +2,6 @@ package sqlite3
 
 import (
 	"context"
-	"errors"
 	"math/rand"
 	"runtime"
 	"strconv"
@@ -21,11 +20,13 @@ type Txn struct {
 }
 
 // Begin starts a deferred transaction.
+// It panics if a transaction is in-progress.
+// For nested transactions, use [Conn.Savepoint].
 //
 // https://sqlite.org/lang_transaction.html
 func (c *Conn) Begin() Txn {
 	// BEGIN even if interrupted.
-	err := c.txnExecInterrupted(`BEGIN DEFERRED`)
+	err := c.exec(`BEGIN DEFERRED`)
 	if err != nil {
 		panic(err)
 	}
@@ -120,7 +121,8 @@ func (tx Txn) Commit() error {
 //
 // https://sqlite.org/lang_transaction.html
 func (tx Txn) Rollback() error {
-	return tx.c.txnExecInterrupted(`ROLLBACK`)
+	// ROLLBACK even if interrupted.
+	return tx.c.exec(`ROLLBACK`)
 }
 
 // Savepoint is a marker within a transaction
@@ -143,7 +145,7 @@ func (c *Conn) Savepoint() Savepoint {
 	// Names can be reused, but this makes catching bugs more likely.
 	name = QuoteIdentifier(name + "_" + strconv.Itoa(int(rand.Int31())))
 
-	err := c.txnExecInterrupted(`SAVEPOINT ` + name)
+	err := c.exec(`SAVEPOINT ` + name)
 	if err != nil {
 		panic(err)
 	}
@@ -199,7 +201,7 @@ func (s Savepoint) Release(errp *error) {
 		return
 	}
 	// ROLLBACK and RELEASE even if interrupted.
-	err := s.c.txnExecInterrupted(`ROLLBACK TO ` + s.name + `; RELEASE ` + s.name)
+	err := s.c.exec(`ROLLBACK TO ` + s.name + `; RELEASE ` + s.name)
 	if err != nil {
 		panic(err)
 	}
@@ -212,17 +214,7 @@ func (s Savepoint) Release(errp *error) {
 // https://sqlite.org/lang_transaction.html
 func (s Savepoint) Rollback() error {
 	// ROLLBACK even if interrupted.
-	return s.c.txnExecInterrupted(`ROLLBACK TO ` + s.name)
-}
-
-func (c *Conn) txnExecInterrupted(sql string) error {
-	err := c.Exec(sql)
-	if errors.Is(err, INTERRUPT) {
-		old := c.SetInterrupt(context.Background())
-		defer c.SetInterrupt(old)
-		err = c.Exec(sql)
-	}
-	return err
+	return s.c.exec(`ROLLBACK TO ` + s.name)
 }
 
 // TxnState determines the transaction state of a database.

util/osutil/open.go

@@ -1,16 +0,0 @@
-//go:build !windows
-
-package osutil
-
-import (
-	"io/fs"
-	"os"
-)
-
-// OpenFile behaves the same as [os.OpenFile],
-// except on Windows it sets [syscall.FILE_SHARE_DELETE].
-//
-// See: https://go.dev/issue/32088#issuecomment-502850674
-func OpenFile(name string, flag int, perm fs.FileMode) (*os.File, error) {
-	return os.OpenFile(name, flag, perm)
-}

util/osutil/open_windows.go

@@ -1,115 +0,0 @@
-package osutil
-
-import (
-	"io/fs"
-	"os"
-	. "syscall"
-	"unsafe"
-)
-
-// OpenFile behaves the same as [os.OpenFile],
-// except on Windows it sets [syscall.FILE_SHARE_DELETE].
-//
-// See: https://go.dev/issue/32088#issuecomment-502850674
-func OpenFile(name string, flag int, perm fs.FileMode) (*os.File, error) {
-	if name == "" {
-		return nil, &os.PathError{Op: "open", Path: name, Err: ENOENT}
-	}
-	r, e := syscallOpen(name, flag|O_CLOEXEC, uint32(perm.Perm()))
-	if e != nil {
-		return nil, &os.PathError{Op: "open", Path: name, Err: e}
-	}
-	return os.NewFile(uintptr(r), name), nil
-}
-
-// syscallOpen is a copy of [syscall.Open]
-// that uses [syscall.FILE_SHARE_DELETE].
-//
-// https://go.dev/src/syscall/syscall_windows.go
-func syscallOpen(path string, mode int, perm uint32) (fd Handle, err error) {
-	if len(path) == 0 {
-		return InvalidHandle, ERROR_FILE_NOT_FOUND
-	}
-	pathp, err := UTF16PtrFromString(path)
-	if err != nil {
-		return InvalidHandle, err
-	}
-	var access uint32
-	switch mode & (O_RDONLY | O_WRONLY | O_RDWR) {
-	case O_RDONLY:
-		access = GENERIC_READ
-	case O_WRONLY:
-		access = GENERIC_WRITE
-	case O_RDWR:
-		access = GENERIC_READ | GENERIC_WRITE
-	}
-	if mode&O_CREAT != 0 {
-		access |= GENERIC_WRITE
-	}
-	if mode&O_APPEND != 0 {
-		access &^= GENERIC_WRITE
-		access |= FILE_APPEND_DATA
-	}
-	sharemode := uint32(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE)
-	var sa *SecurityAttributes
-	if mode&O_CLOEXEC == 0 {
-		sa = makeInheritSa()
-	}
-	var createmode uint32
-	switch {
-	case mode&(O_CREAT|O_EXCL) == (O_CREAT | O_EXCL):
-		createmode = CREATE_NEW
-	case mode&(O_CREAT|O_TRUNC) == (O_CREAT | O_TRUNC):
-		createmode = CREATE_ALWAYS
-	case mode&O_CREAT == O_CREAT:
-		createmode = OPEN_ALWAYS
-	case mode&O_TRUNC == O_TRUNC:
-		createmode = TRUNCATE_EXISTING
-	default:
-		createmode = OPEN_EXISTING
-	}
-	var attrs uint32 = FILE_ATTRIBUTE_NORMAL
-	if perm&S_IWRITE == 0 {
-		attrs = FILE_ATTRIBUTE_READONLY
-		if createmode == CREATE_ALWAYS {
-			const _ERROR_BAD_NETPATH = Errno(53)
-			// We have been asked to create a read-only file.
-			// If the file already exists, the semantics of
-			// the Unix open system call is to preserve the
-			// existing permissions. If we pass CREATE_ALWAYS
-			// and FILE_ATTRIBUTE_READONLY to CreateFile,
-			// and the file already exists, CreateFile will
-			// change the file permissions.
-			// Avoid that to preserve the Unix semantics.
-			h, e := CreateFile(pathp, access, sharemode, sa, TRUNCATE_EXISTING, FILE_ATTRIBUTE_NORMAL, 0)
-			switch e {
-			case ERROR_FILE_NOT_FOUND, _ERROR_BAD_NETPATH, ERROR_PATH_NOT_FOUND:
-				// File does not exist. These are the same
-				// errors as Errno.Is checks for ErrNotExist.
-				// Carry on to create the file.
-			default:
-				// Success or some different error.
-				return h, e
-			}
-		}
-	}
-	if createmode == OPEN_EXISTING && access == GENERIC_READ {
-		// Necessary for opening directory handles.
-		attrs |= FILE_FLAG_BACKUP_SEMANTICS
-	}
-	if mode&O_SYNC != 0 {
-		const _FILE_FLAG_WRITE_THROUGH = 0x80000000
-		attrs |= _FILE_FLAG_WRITE_THROUGH
-	}
-	if mode&O_NONBLOCK != 0 {
-		attrs |= FILE_FLAG_OVERLAPPED
-	}
-	return CreateFile(pathp, access, sharemode, sa, createmode, attrs, 0)
-}
-
-func makeInheritSa() *SecurityAttributes {
-	var sa SecurityAttributes
-	sa.Length = uint32(unsafe.Sizeof(sa))
-	sa.InheritHandle = 1
-	return &sa
-}

util/osutil/osfs.go

@@ -1,3 +1,4 @@
+// Package osutil implements operating system utilities.
 package osutil
 
 import (
@@ -19,7 +20,7 @@ type FS struct{}
 
 // Open implements [fs.FS].
 func (FS) Open(name string) (fs.File, error) {
-	return OpenFile(name, os.O_RDONLY, 0)
+	return os.OpenFile(name, os.O_RDONLY, 0)
 }
 
 // ReadFileFS implements [fs.StatFS].
@@ -31,3 +32,10 @@ func (FS) Stat(name string) (fs.FileInfo, error) {
 func (FS) ReadFile(name string) ([]byte, error) {
 	return os.ReadFile(name)
 }
+
+// OpenFile behaves the same as [os.OpenFile].
+//
+// Deprecated: use os.OpenFile instead.
+func OpenFile(name string, flag int, perm fs.FileMode) (*os.File, error) {
+	return os.OpenFile(name, flag, perm)
+}

util/osutil/osutil.go

@@ -1,2 +0,0 @@
-// Package osutil implements operating system utilities.
-package osutil

util/sql3util/sql3util.go

@@ -5,5 +5,5 @@ package sql3util
 //
 // https://sqlite.org/fileformat.html#pages
 func ValidPageSize(s int) bool {
-	return 512 <= s && s <= 65536 && s&(s-1) == 0
+	return s&(s-1) == 0 && 512 <= s && s <= 65536
 }

value.go

@@ -139,7 +139,7 @@ func (v Value) Blob(buf []byte) []byte {
 // https://sqlite.org/c3ref/value_blob.html
 func (v Value) RawText() []byte {
 	ptr := ptr_t(v.c.call("sqlite3_value_text", v.protected()))
-	return v.rawBytes(ptr)
+	return v.rawBytes(ptr, 1)
 }
 
 // RawBlob returns the value as a []byte.
@@ -149,16 +149,16 @@ func (v Value) RawText() []byte {
 // https://sqlite.org/c3ref/value_blob.html
 func (v Value) RawBlob() []byte {
 	ptr := ptr_t(v.c.call("sqlite3_value_blob", v.protected()))
-	return v.rawBytes(ptr)
+	return v.rawBytes(ptr, 0)
 }
 
-func (v Value) rawBytes(ptr ptr_t) []byte {
+func (v Value) rawBytes(ptr ptr_t, nul int32) []byte {
 	if ptr == 0 {
 		return nil
 	}
 
 	n := int32(v.c.call("sqlite3_value_bytes", v.protected()))
-	return util.View(v.c.mod, ptr, int64(n))
+	return util.View(v.c.mod, ptr, int64(n+nul))[:n]
 }
 
 // Pointer gets the pointer associated with this value,

vfs/README.md

@@ -6,22 +6,30 @@ It replaces the default SQLite VFS with a **pure Go** implementation,
 and exposes [interfaces](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs#VFS)
 that should allow you to implement your own [custom VFSes](#custom-vfses).
 
-Since it is a from scratch reimplementation,
-there are naturally some ways it deviates from the original.
+See the [support matrix](https://github.com/ncruces/go-sqlite3/wiki/Support-matrix)
+for the list of supported OS and CPU architectures.
 
-The main differences are [file locking](#file-locking) and [WAL mode](#write-ahead-logging) support.
+Since this is a from scratch reimplementation,
+there are naturally some ways it deviates from the original.
+It's also not as battle tested as the original.
+
+The main differences to be aware of are
+[file locking](#file-locking) and
+[WAL mode](#write-ahead-logging) support.
 
 ### File Locking
 
-POSIX advisory locks, which SQLite uses on Unix, are
-[broken by design](https://github.com/sqlite/sqlite/blob/b74eb0/src/os_unix.c#L1073-L1161).
+POSIX advisory locks,
+which SQLite uses on [Unix](https://github.com/sqlite/sqlite/blob/5d60f4/src/os_unix.c#L13-L14),
+are [broken by design](https://github.com/sqlite/sqlite/blob/5d60f4/src/os_unix.c#L1074-L1162).
 Instead, on Linux and macOS, this package uses
 [OFD locks](https://www.gnu.org/software/libc/manual/html_node/Open-File-Description-Locks.html)
 to synchronize access to database files.
 
 This package can also use
 [BSD locks](https://man.freebsd.org/cgi/man.cgi?query=flock&sektion=2),
-albeit with reduced concurrency (`BEGIN IMMEDIATE` behaves like `BEGIN EXCLUSIVE`).
+albeit with reduced concurrency (`BEGIN IMMEDIATE` behaves like `BEGIN EXCLUSIVE`,
+[docs](https://sqlite.org/lang_transaction.html#immediate)).
 BSD locks are the default on BSD and illumos,
 but you can opt into them with the `sqlite3_flock` build tag.
 
@@ -44,11 +52,11 @@ to check if your build supports file locking.
 
 ### Write-Ahead Logging
 
-On Unix, this package may use `mmap` to implement
+On Unix, this package uses `mmap` to implement
 [shared-memory for the WAL-index](https://sqlite.org/wal.html#implementation_of_shared_memory_for_the_wal_index),
 like SQLite.
 
-On Windows, this package may use `MapViewOfFile`, like SQLite.
+On Windows, this package uses `MapViewOfFile`, like SQLite.
 
 You can also opt into a cross-platform, in-process, memory sharing implementation
 with the `sqlite3_dotlk` build tag.
@@ -63,6 +71,11 @@ you must disable connection pooling by calling
 You can use [`vfs.SupportsSharedMemory`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs#SupportsSharedMemory)
 to check if your build supports shared memory.
 
+### Blocking Locks
+
+On Windows and macOS, this package implements
+[Wal-mode blocking locks](https://sqlite.org/src/doc/tip/doc/wal-lock.md).
+
 ### Batch-Atomic Write
 
 On Linux, this package may support
@@ -94,8 +107,10 @@ The VFS can be customized with a few build tags:
 > [`unix-flock` VFS](https://sqlite.org/compile.html#enable_locking_style);
 > `sqlite3_dotlk` builds are compatible with the
 > [`unix-dotfile` VFS](https://sqlite.org/compile.html#enable_locking_style).
-> If incompatible file locking is used, accessing databases concurrently with
-> _other_ SQLite libraries will eventually corrupt data.
+
+> [!CAUTION]
+> Concurrently accessing databases using incompatible VFSes
+> will eventually corrupt data.
 
 ### Custom VFSes
 

vfs/cksm.go

@@ -47,11 +47,10 @@ type cksmFlags struct {
 
 func (c cksmFile) ReadAt(p []byte, off int64) (n int, err error) {
 	n, err = c.File.ReadAt(p, off)
+	p = p[:n]
 
-	// SQLite is reading the header of a database file.
-	if c.isDB && off == 0 && len(p) >= 100 &&
-		bytes.HasPrefix(p, []byte("SQLite format 3\000")) {
-		c.init(p)
+	if isHeader(c.isDB, p, off) {
+		c.init((*[100]byte)(p))
 	}
 
 	// Verify checksums.
@@ -66,10 +65,8 @@ func (c cksmFile) ReadAt(p []byte, off int64) (n int, err error) {
 }
 
 func (c cksmFile) WriteAt(p []byte, off int64) (n int, err error) {
-	// SQLite is writing the first page of a database file.
-	if c.isDB && off == 0 && len(p) >= 100 &&
-		bytes.HasPrefix(p, []byte("SQLite format 3\000")) {
-		c.init(p)
+	if isHeader(c.isDB, p, off) {
+		c.init((*[100]byte)(p))
 	}
 
 	// Compute checksums.
@@ -115,19 +112,33 @@ func (c cksmFile) fileControl(ctx context.Context, mod api.Module, op _FcntlOpco
 		c.inCkpt = true
 	case _FCNTL_CKPT_DONE:
 		c.inCkpt = false
-	}
-	if rc := vfsFileControlImpl(ctx, mod, c, op, pArg); rc != _NOTFOUND {
-		return rc
+	case _FCNTL_PRAGMA:
+		rc := vfsFileControlImpl(ctx, mod, c, op, pArg)
+		if rc != _NOTFOUND {
+			return rc
+		}
 	}
 	return vfsFileControlImpl(ctx, mod, c.File, op, pArg)
 }
 
-func (f *cksmFlags) init(header []byte) {
+func (f *cksmFlags) init(header *[100]byte) {
 	f.pageSize = 256 * int(binary.LittleEndian.Uint16(header[16:18]))
 	if r := header[20] == 8; r != f.computeCksm {
 		f.computeCksm = r
 		f.verifyCksm = r
 	}
+	if !sql3util.ValidPageSize(f.pageSize) {
+		f.computeCksm = false
+		f.verifyCksm = false
+	}
+}
+
+func isHeader(isDB bool, p []byte, off int64) bool {
+	check := sql3util.ValidPageSize(len(p))
+	if isDB {
+		check = off == 0 && len(p) >= 100
+	}
+	return check && bytes.HasPrefix(p, []byte("SQLite format 3\000"))
 }
 
 func cksmCompute(a []byte) (cksm [8]byte) {

vfs/const.go

@@ -31,6 +31,7 @@ const (
 	_READONLY                _ErrorCode = util.READONLY
 	_IOERR                   _ErrorCode = util.IOERR
 	_NOTFOUND                _ErrorCode = util.NOTFOUND
+	_FULL                    _ErrorCode = util.FULL
 	_CANTOPEN                _ErrorCode = util.CANTOPEN
 	_IOERR_READ              _ErrorCode = util.IOERR_READ
 	_IOERR_SHORT_READ        _ErrorCode = util.IOERR_SHORT_READ
@@ -57,10 +58,12 @@ const (
 	_IOERR_COMMIT_ATOMIC     _ErrorCode = util.IOERR_COMMIT_ATOMIC
 	_IOERR_ROLLBACK_ATOMIC   _ErrorCode = util.IOERR_ROLLBACK_ATOMIC
 	_IOERR_DATA              _ErrorCode = util.IOERR_DATA
+	_IOERR_CORRUPTFS         _ErrorCode = util.IOERR_CORRUPTFS
 	_BUSY_SNAPSHOT           _ErrorCode = util.BUSY_SNAPSHOT
 	_CANTOPEN_FULLPATH       _ErrorCode = util.CANTOPEN_FULLPATH
 	_CANTOPEN_ISDIR          _ErrorCode = util.CANTOPEN_ISDIR
 	_READONLY_CANTINIT       _ErrorCode = util.READONLY_CANTINIT
+	_READONLY_DIRECTORY      _ErrorCode = util.READONLY_DIRECTORY
 	_OK_SYMLINK              _ErrorCode = util.OK_SYMLINK
 )
 

vfs/file.go

@@ -6,9 +6,8 @@ import (
 	"io/fs"
 	"os"
 	"path/filepath"
+	"runtime"
 	"syscall"
-
-	"github.com/ncruces/go-sqlite3/util/osutil"
 )
 
 type vfsOS struct{}
@@ -40,7 +39,7 @@ func (vfsOS) Delete(path string, syncDir bool) error {
 	if err != nil {
 		return err
 	}
-	if canSyncDirs && syncDir {
+	if isUnix && syncDir {
 		f, err := os.Open(filepath.Dir(path))
 		if err != nil {
 			return _OK
@@ -88,12 +87,15 @@ func (vfsOS) OpenFilename(name *Filename, flags OpenFlag) (File, OpenFlag, error
 		oflags |= os.O_RDWR
 	}
 
+	isCreate := flags&(OPEN_CREATE) != 0
+	isJournl := flags&(OPEN_MAIN_JOURNAL|OPEN_SUPER_JOURNAL|OPEN_WAL) != 0
+
 	var err error
 	var f *os.File
 	if name == nil {
-		f, err = os.CreateTemp("", "*.db")
+		f, err = os.CreateTemp(os.Getenv("SQLITE_TMPDIR"), "*.db")
 	} else {
-		f, err = osutil.OpenFile(name.String(), oflags, 0666)
+		f, err = os.OpenFile(name.String(), oflags, 0666)
 	}
 	if err != nil {
 		if name == nil {
@@ -102,6 +104,10 @@ func (vfsOS) OpenFilename(name *Filename, flags OpenFlag) (File, OpenFlag, error
 		if errors.Is(err, syscall.EISDIR) {
 			return nil, flags, _CANTOPEN_ISDIR
 		}
+		if isCreate && isJournl && errors.Is(err, fs.ErrPermission) &&
+			osAccess(name.String(), ACCESS_EXISTS) != nil {
+			return nil, flags, _READONLY_DIRECTORY
+		}
 		return nil, flags, err
 	}
 
@@ -111,18 +117,18 @@ func (vfsOS) OpenFilename(name *Filename, flags OpenFlag) (File, OpenFlag, error
 			return nil, flags, _IOERR_FSTAT
 		}
 	}
-	if flags&OPEN_DELETEONCLOSE != 0 {
+	if isUnix && flags&OPEN_DELETEONCLOSE != 0 {
 		os.Remove(f.Name())
 	}
 
 	file := vfsFile{
 		File:     f,
 		psow:     true,
+		atomic:   osBatchAtomic(f),
 		readOnly: flags&OPEN_READONLY != 0,
-		syncDir: canSyncDirs &&
-			flags&(OPEN_MAIN_JOURNAL|OPEN_SUPER_JOURNAL|OPEN_WAL) != 0 &&
-			flags&(OPEN_CREATE) != 0,
-		shm: NewSharedMemory(name.String()+"-shm", flags),
+		syncDir:  isUnix && isCreate && isJournl,
+		delete:   !isUnix && flags&OPEN_DELETEONCLOSE != 0,
+		shm:      NewSharedMemory(name.String()+"-shm", flags),
 	}
 	return &file, flags, nil
 }
@@ -134,6 +140,8 @@ type vfsFile struct {
 	readOnly bool
 	keepWAL  bool
 	syncDir  bool
+	atomic   bool
+	delete   bool
 	psow     bool
 }
 
@@ -147,6 +155,9 @@ var (
 )
 
 func (f *vfsFile) Close() error {
+	if f.delete {
+		defer os.Remove(f.Name())
+	}
 	if f.shm != nil {
 		f.shm.Close()
 	}
@@ -154,6 +165,14 @@ func (f *vfsFile) Close() error {
 	return f.File.Close()
 }
 
+func (f *vfsFile) ReadAt(p []byte, off int64) (n int, err error) {
+	return osReadAt(f.File, p, off)
+}
+
+func (f *vfsFile) WriteAt(p []byte, off int64) (n int, err error) {
+	return osWriteAt(f.File, p, off)
+}
+
 func (f *vfsFile) Sync(flags SyncFlag) error {
 	dataonly := (flags & SYNC_DATAONLY) != 0
 	fullsync := (flags & 0x0f) == SYNC_FULL
@@ -162,7 +181,7 @@ func (f *vfsFile) Sync(flags SyncFlag) error {
 	if err != nil {
 		return err
 	}
-	if canSyncDirs && f.syncDir {
+	if isUnix && f.syncDir {
 		f.syncDir = false
 		d, err := os.Open(filepath.Dir(f.File.Name()))
 		if err != nil {
@@ -187,12 +206,15 @@ func (f *vfsFile) SectorSize() int {
 
 func (f *vfsFile) DeviceCharacteristics() DeviceCharacteristic {
 	ret := IOCAP_SUBPAGE_READ
-	if osBatchAtomic(f.File) {
+	if f.atomic {
 		ret |= IOCAP_BATCH_ATOMIC
 	}
 	if f.psow {
 		ret |= IOCAP_POWERSAFE_OVERWRITE
 	}
+	if runtime.GOOS == "windows" {
+		ret |= IOCAP_UNDELETABLE_WHEN_OPEN
+	}
 	return ret
 }
 
@@ -201,6 +223,9 @@ func (f *vfsFile) SizeHint(size int64) error {
 }
 
 func (f *vfsFile) HasMoved() (bool, error) {
+	if runtime.GOOS == "windows" {
+		return false, nil
+	}
 	fi, err := f.Stat()
 	if err != nil {
 		return false, err

vfs/os_bsd.go

@@ -50,11 +50,15 @@ func osDowngradeLock(file *os.File, _ LockLevel) _ErrorCode {
 }
 
 func osReleaseLock(file *os.File, _ LockLevel) _ErrorCode {
-	err := unix.Flock(int(file.Fd()), unix.LOCK_UN)
-	if err != nil {
-		return _IOERR_UNLOCK
+	for {
+		err := unix.Flock(int(file.Fd()), unix.LOCK_UN)
+		if err == nil {
+			return _OK
+		}
+		if err != unix.EINTR {
+			return _IOERR_UNLOCK
+		}
 	}
-	return _OK
 }
 
 func osCheckReservedLock(file *os.File) (bool, _ErrorCode) {
@@ -89,13 +93,18 @@ func osLock(file *os.File, typ int16, start, len int64, def _ErrorCode) _ErrorCo
 }
 
 func osUnlock(file *os.File, start, len int64) _ErrorCode {
-	err := unix.FcntlFlock(file.Fd(), unix.F_SETLK, &unix.Flock_t{
+	lock := unix.Flock_t{
 		Type:  unix.F_UNLCK,
 		Start: start,
 		Len:   len,
-	})
-	if err != nil {
-		return _IOERR_UNLOCK
 	}
-	return _OK
+	for {
+		err := unix.FcntlFlock(file.Fd(), unix.F_SETLK, &lock)
+		if err == nil {
+			return _OK
+		}
+		if err != unix.EINTR {
+			return _IOERR_UNLOCK
+		}
+	}
 }

vfs/os_darwin.go

@@ -27,7 +27,12 @@ func osSync(file *os.File, fullsync, _ /*dataonly*/ bool) error {
 	if fullsync {
 		return file.Sync()
 	}
-	return unix.Fsync(int(file.Fd()))
+	for {
+		err := unix.Fsync(int(file.Fd()))
+		if err != unix.EINTR {
+			return err
+		}
+	}
 }
 
 func osAllocate(file *os.File, size int64) error {
@@ -85,13 +90,18 @@ func osLock(file *os.File, typ int16, start, len int64, timeout time.Duration, d
 }
 
 func osUnlock(file *os.File, start, len int64) _ErrorCode {
-	err := unix.FcntlFlock(file.Fd(), _F_OFD_SETLK, &unix.Flock_t{
+	lock := unix.Flock_t{
 		Type:  unix.F_UNLCK,
 		Start: start,
 		Len:   len,
-	})
-	if err != nil {
-		return _IOERR_UNLOCK
 	}
-	return _OK
+	for {
+		err := unix.FcntlFlock(file.Fd(), _F_OFD_SETLK, &lock)
+		if err == nil {
+			return _OK
+		}
+		if err != unix.EINTR {
+			return _IOERR_UNLOCK
+		}
+	}
 }

vfs/os_linux.go

@@ -3,6 +3,7 @@
 package vfs
 
 import (
+	"io"
 	"os"
 	"time"
 
@@ -11,14 +12,36 @@ import (
 
 func osSync(file *os.File, _ /*fullsync*/, _ /*dataonly*/ bool) error {
 	// SQLite trusts Linux's fdatasync for all fsync's.
-	return unix.Fdatasync(int(file.Fd()))
+	for {
+		err := unix.Fdatasync(int(file.Fd()))
+		if err != unix.EINTR {
+			return err
+		}
+	}
 }
 
 func osAllocate(file *os.File, size int64) error {
 	if size == 0 {
 		return nil
 	}
-	return unix.Fallocate(int(file.Fd()), 0, 0, size)
+	for {
+		err := unix.Fallocate(int(file.Fd()), 0, 0, size)
+		if err == unix.EOPNOTSUPP {
+			break
+		}
+		if err != unix.EINTR {
+			return err
+		}
+	}
+	off, err := file.Seek(0, io.SeekEnd)
+	if err != nil {
+		return err
+	}
+	if size <= off {
+		return nil
+	}
+	return file.Truncate(size)
+
 }
 
 func osReadLock(file *os.File, start, len int64, timeout time.Duration) _ErrorCode {
@@ -37,22 +60,27 @@ func osLock(file *os.File, typ int16, start, len int64, timeout time.Duration, d
 	}
 	var err error
 	switch {
-	case timeout < 0:
-		err = unix.FcntlFlock(file.Fd(), unix.F_OFD_SETLKW, &lock)
 	default:
 		err = unix.FcntlFlock(file.Fd(), unix.F_OFD_SETLK, &lock)
+	case timeout < 0:
+		err = unix.FcntlFlock(file.Fd(), unix.F_OFD_SETLKW, &lock)
 	}
 	return osLockErrorCode(err, def)
 }
 
 func osUnlock(file *os.File, start, len int64) _ErrorCode {
-	err := unix.FcntlFlock(file.Fd(), unix.F_OFD_SETLK, &unix.Flock_t{
+	lock := unix.Flock_t{
 		Type:  unix.F_UNLCK,
 		Start: start,
 		Len:   len,
-	})
-	if err != nil {
-		return _IOERR_UNLOCK
 	}
-	return _OK
+	for {
+		err := unix.FcntlFlock(file.Fd(), unix.F_OFD_SETLK, &lock)
+		if err == nil {
+			return _OK
+		}
+		if err != unix.EINTR {
+			return _IOERR_UNLOCK
+		}
+	}
 }

vfs/os_std.go

@@ -8,8 +8,8 @@ import (
 )
 
 const (
+	isUnix      = false
 	_O_NOFOLLOW = 0
-	canSyncDirs = false
 )
 
 func osAccess(path string, flags AccessFlag) error {

vfs/os_std_rw.go

@@ -0,0 +1,13 @@
+//go:build !unix && (!windows || sqlite3_dotlk)
+
+package vfs
+
+import "os"
+
+func osReadAt(file *os.File, p []byte, off int64) (int, error) {
+	return file.ReadAt(p, off)
+}
+
+func osWriteAt(file *os.File, p []byte, off int64) (int, error) {
+	return file.WriteAt(p, off)
+}

vfs/os_unix.go

@@ -10,8 +10,8 @@ import (
 )
 
 const (
+	isUnix      = true
 	_O_NOFOLLOW = unix.O_NOFOLLOW
-	canSyncDirs = true
 )
 
 func osAccess(path string, flags AccessFlag) error {
@@ -25,6 +25,28 @@ func osAccess(path string, flags AccessFlag) error {
 	return unix.Access(path, access)
 }
 
+func osReadAt(file *os.File, p []byte, off int64) (int, error) {
+	n, err := file.ReadAt(p, off)
+	if errno, ok := err.(unix.Errno); ok {
+		switch errno {
+		case
+			unix.ERANGE,
+			unix.EIO,
+			unix.ENXIO:
+			return n, _IOERR_CORRUPTFS
+		}
+	}
+	return n, err
+}
+
+func osWriteAt(file *os.File, p []byte, off int64) (int, error) {
+	n, err := file.WriteAt(p, off)
+	if errno, ok := err.(unix.Errno); ok && errno == unix.ENOSPC {
+		return n, _FULL
+	}
+	return n, err
+}
+
 func osSetMode(file *os.File, modeof string) error {
 	fi, err := os.Stat(modeof)
 	if err != nil {
@@ -43,10 +65,15 @@ func osTestLock(file *os.File, start, len int64) (int16, _ErrorCode) {
 		Start: start,
 		Len:   len,
 	}
-	if unix.FcntlFlock(file.Fd(), unix.F_GETLK, &lock) != nil {
-		return 0, _IOERR_CHECKRESERVEDLOCK
+	for {
+		err := unix.FcntlFlock(file.Fd(), unix.F_GETLK, &lock)
+		if err == nil {
+			return lock.Type, _OK
+		}
+		if err != unix.EINTR {
+			return 0, _IOERR_CHECKRESERVEDLOCK
+		}
 	}
-	return lock.Type, _OK
 }
 
 func osLockErrorCode(err error, def _ErrorCode) _ErrorCode {

vfs/os_windows.go

@@ -9,6 +9,23 @@ import (
 	"golang.org/x/sys/windows"
 )
 
+func osReadAt(file *os.File, p []byte, off int64) (int, error) {
+	return file.ReadAt(p, off)
+}
+
+func osWriteAt(file *os.File, p []byte, off int64) (int, error) {
+	n, err := file.WriteAt(p, off)
+	if errno, ok := err.(windows.Errno); ok {
+		switch errno {
+		case
+			windows.ERROR_HANDLE_DISK_FULL,
+			windows.ERROR_DISK_FULL:
+			return n, _FULL
+		}
+	}
+	return n, err
+}
+
 func osGetSharedLock(file *os.File) _ErrorCode {
 	// Acquire the PENDING lock temporarily before acquiring a new SHARED lock.
 	rc := osReadLock(file, _PENDING_BYTE, 1, 0)
@@ -118,12 +135,10 @@ func osWriteLock(file *os.File, start, len uint32, timeout time.Duration) _Error
 func osLock(file *os.File, flags, start, len uint32, timeout time.Duration, def _ErrorCode) _ErrorCode {
 	var err error
 	switch {
-	case timeout == 0:
+	default:
 		err = osLockEx(file, flags|windows.LOCKFILE_FAIL_IMMEDIATELY, start, len)
 	case timeout < 0:
 		err = osLockEx(file, flags, start, len)
-	default:
-		err = osLockExTimeout(file, flags, start, len, timeout)
 	}
 	return osLockErrorCode(err, def)
 }
@@ -145,37 +160,6 @@ func osLockEx(file *os.File, flags, start, len uint32) error {
 		0, len, 0, &windows.Overlapped{Offset: start})
 }
 
-func osLockExTimeout(file *os.File, flags, start, len uint32, timeout time.Duration) error {
-	event, err := windows.CreateEvent(nil, 1, 0, nil)
-	if err != nil {
-		return err
-	}
-	defer windows.CloseHandle(event)
-
-	fd := windows.Handle(file.Fd())
-	overlapped := &windows.Overlapped{
-		Offset: start,
-		HEvent: event,
-	}
-
-	err = windows.LockFileEx(fd, flags, 0, len, 0, overlapped)
-	if err != windows.ERROR_IO_PENDING {
-		return err
-	}
-
-	ms := (timeout + time.Millisecond - 1) / time.Millisecond
-	rc, err := windows.WaitForSingleObject(event, uint32(ms))
-	if rc == windows.WAIT_OBJECT_0 {
-		return nil
-	}
-	defer windows.CancelIoEx(fd, overlapped)
-
-	if err != nil {
-		return err
-	}
-	return windows.Errno(rc)
-}
-
 func osLockErrorCode(err error, def _ErrorCode) _ErrorCode {
 	if err == nil {
 		return _OK

vfs/shm_bsd.go

@@ -68,16 +68,11 @@ func (s *vfsShm) Close() error {
 	panic(util.AssertErr())
 }
 
-func (s *vfsShm) shmOpen() _ErrorCode {
+func (s *vfsShm) shmOpen() (rc _ErrorCode) {
 	if s.vfsShmParent != nil {
 		return _OK
 	}
 
-	var f *os.File
-	// Close file on error.
-	// Keep this here to avoid confusing checklocks.
-	defer func() { f.Close() }()
-
 	vfsShmListMtx.Lock()
 	defer vfsShmListMtx.Unlock()
 
@@ -98,11 +93,16 @@ func (s *vfsShm) shmOpen() _ErrorCode {
 	}
 
 	// Always open file read-write, as it will be shared.
-	f, err = os.OpenFile(s.path,
+	f, err := os.OpenFile(s.path,
 		os.O_RDWR|os.O_CREATE|_O_NOFOLLOW, 0666)
 	if err != nil {
 		return _CANTOPEN
 	}
+	defer func() {
+		if rc != _OK {
+			f.Close()
+		}
+	}()
 
 	// Dead man's switch.
 	if lock, rc := osTestLock(f, _SHM_DMS, 1); rc != _OK {
@@ -131,7 +131,6 @@ func (s *vfsShm) shmOpen() _ErrorCode {
 		File: f,
 		info: fi,
 	}
-	f = nil // Don't close the file.
 	for i, g := range vfsShmList {
 		if g == nil {
 			vfsShmList[i] = s.vfsShmParent

vfs/shm_windows.go

@@ -7,14 +7,11 @@ import (
 	"io"
 	"os"
 	"sync"
-	"syscall"
-	"time"
 
 	"github.com/tetratelabs/wazero/api"
 	"golang.org/x/sys/windows"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
-	"github.com/ncruces/go-sqlite3/util/osutil"
 )
 
 type vfsShm struct {
@@ -33,8 +30,6 @@ type vfsShm struct {
 	sync.Mutex
 }
 
-var _ blockingSharedMemory = &vfsShm{}
-
 func (s *vfsShm) Close() error {
 	// Unmap regions.
 	for _, r := range s.regions {
@@ -48,8 +43,7 @@ func (s *vfsShm) Close() error {
 
 func (s *vfsShm) shmOpen() _ErrorCode {
 	if s.File == nil {
-		f, err := osutil.OpenFile(s.path,
-			os.O_RDWR|os.O_CREATE|syscall.O_NONBLOCK, 0666)
+		f, err := os.OpenFile(s.path, os.O_RDWR|os.O_CREATE, 0666)
 		if err != nil {
 			return _CANTOPEN
 		}
@@ -67,7 +61,7 @@ func (s *vfsShm) shmOpen() _ErrorCode {
 			return _IOERR_SHMOPEN
 		}
 	}
-	rc := osReadLock(s.File, _SHM_DMS, 1, time.Millisecond)
+	rc := osReadLock(s.File, _SHM_DMS, 1, 0)
 	s.fileLock = rc == _OK
 	return rc
 }
@@ -135,11 +129,6 @@ func (s *vfsShm) shmMap(ctx context.Context, mod api.Module, id, size int32, ext
 }
 
 func (s *vfsShm) shmLock(offset, n int32, flags _ShmFlag) (rc _ErrorCode) {
-	var timeout time.Duration
-	if s.blocking {
-		timeout = time.Millisecond
-	}
-
 	switch {
 	case flags&_SHM_LOCK != 0:
 		defer s.shmAcquire(&rc)
@@ -151,9 +140,9 @@ func (s *vfsShm) shmLock(offset, n int32, flags _ShmFlag) (rc _ErrorCode) {
 	case flags&_SHM_UNLOCK != 0:
 		return osUnlock(s.File, _SHM_BASE+uint32(offset), uint32(n))
 	case flags&_SHM_SHARED != 0:
-		return osReadLock(s.File, _SHM_BASE+uint32(offset), uint32(n), timeout)
+		return osReadLock(s.File, _SHM_BASE+uint32(offset), uint32(n), 0)
 	case flags&_SHM_EXCLUSIVE != 0:
-		return osWriteLock(s.File, _SHM_BASE+uint32(offset), uint32(n), timeout)
+		return osWriteLock(s.File, _SHM_BASE+uint32(offset), uint32(n), 0)
 	default:
 		panic(util.AssertErr())
 	}
@@ -184,7 +173,3 @@ func (s *vfsShm) shmUnmap(delete bool) {
 		os.Remove(s.path)
 	}
 }
-
-func (s *vfsShm) shmEnableBlocking(block bool) {
-	s.blocking = block
-}

vfs/tests/mptest/mptest_test.go

@@ -18,7 +18,6 @@ import (
 
 	"github.com/tetratelabs/wazero"
 	"github.com/tetratelabs/wazero/api"
-	"github.com/tetratelabs/wazero/experimental"
 	"github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
@@ -39,9 +38,7 @@ var (
 
 func TestMain(m *testing.M) {
 	ctx := context.Background()
-	cfg := wazero.NewRuntimeConfig().
-		WithCoreFeatures(api.CoreFeaturesV2 | experimental.CoreFeaturesThreads).
-		WithMemoryLimitPages(512)
+	cfg := wazero.NewRuntimeConfig().WithMemoryLimitPages(512)
 	rt = wazero.NewRuntimeWithConfig(ctx, cfg)
 	wasi_snapshot_preview1.MustInstantiate(ctx, rt)
 	env := vfs.ExportHostFunctions(rt.NewHostModuleBuilder("env"))

vfs/tests/speedtest1/speedtest1_test.go

@@ -15,8 +15,6 @@ import (
 	"testing"
 
 	"github.com/tetratelabs/wazero"
-	"github.com/tetratelabs/wazero/api"
-	"github.com/tetratelabs/wazero/experimental"
 	"github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
@@ -37,9 +35,7 @@ func TestMain(m *testing.M) {
 	initFlags()
 
 	ctx := context.Background()
-	cfg := wazero.NewRuntimeConfig().
-		WithCoreFeatures(api.CoreFeaturesV2 | experimental.CoreFeaturesThreads).
-		WithMemoryLimitPages(512)
+	cfg := wazero.NewRuntimeConfig().WithMemoryLimitPages(512)
 	rt = wazero.NewRuntimeWithConfig(ctx, cfg)
 	wasi_snapshot_preview1.MustInstantiate(ctx, rt)
 	env := vfs.ExportHostFunctions(rt.NewHostModuleBuilder("env"))

vtab.go

@@ -79,9 +79,12 @@ func implements[T any](typ reflect.Type) bool {
 //
 // https://sqlite.org/c3ref/declare_vtab.html
 func (c *Conn) DeclareVTab(sql string) error {
+	if c.interrupt.Err() != nil {
+		return INTERRUPT
+	}
 	defer c.arena.mark()()
-	sqlPtr := c.arena.string(sql)
-	rc := res_t(c.call("sqlite3_declare_vtab", stk_t(c.handle), stk_t(sqlPtr)))
+	textPtr := c.arena.string(sql)
+	rc := res_t(c.call("sqlite3_declare_vtab", stk_t(c.handle), stk_t(textPtr)))
 	return c.error(rc)
 }
 
@@ -162,6 +165,7 @@ type VTabDestroyer interface {
 }
 
 // A VTabUpdater allows a virtual table to be updated.
+// Implementations must not retain arg.
 type VTabUpdater interface {
 	VTab
 	// https://sqlite.org/vtab.html#xupdate
@@ -241,6 +245,7 @@ type VTabSavepointer interface {
 // to loop through the virtual table.
 // A VTabCursor may optionally implement
 // [io.Closer] to free resources.
+// Implementations of Filter must not retain arg.
 //
 // https://sqlite.org/c3ref/vtab_cursor.html
 type VTabCursor interface {
@@ -489,12 +494,12 @@ func vtabBestIndexCallback(ctx context.Context, mod api.Module, pVTab, pIdxInfo
 }
 
 func vtabUpdateCallback(ctx context.Context, mod api.Module, pVTab ptr_t, nArg int32, pArg, pRowID ptr_t) res_t {
-	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabUpdater)
-
 	db := ctx.Value(connKey{}).(*Conn)
-	args := make([]Value, nArg)
-	callbackArgs(db, args, pArg)
-	rowID, err := vtab.Update(args...)
+	args := callbackArgs(db, nArg, pArg)
+	defer returnArgs(args)
+
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabUpdater)
+	rowID, err := vtab.Update(*args...)
 	if err == nil {
 		util.Write64(mod, pRowID, rowID)
 	}
@@ -593,15 +598,17 @@ func cursorCloseCallback(ctx context.Context, mod api.Module, pCur ptr_t) res_t
 }
 
 func cursorFilterCallback(ctx context.Context, mod api.Module, pCur ptr_t, idxNum int32, idxStr ptr_t, nArg int32, pArg ptr_t) res_t {
-	cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor)
 	db := ctx.Value(connKey{}).(*Conn)
-	args := make([]Value, nArg)
-	callbackArgs(db, args, pArg)
+	args := callbackArgs(db, nArg, pArg)
+	defer returnArgs(args)
+
 	var idxName string
 	if idxStr != 0 {
 		idxName = util.ReadString(mod, idxStr, _MAX_LENGTH)
 	}
-	err := cursor.Filter(int(idxNum), idxName, args...)
+
+	cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor)
+	err := cursor.Filter(int(idxNum), idxName, *args...)
 	return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err)
 }