Remove rangefunc experiment.

Bumps [github.com/tetratelabs/wazero](https://github.com/tetratelabs/wazero) from 1.8.0 to 1.8.1.
- [Release notes](https://github.com/tetratelabs/wazero/releases)
- [Commits](https://github.com/tetratelabs/wazero/compare/v1.8.0...v1.8.1)

---
updated-dependencies:
- dependency-name: github.com/tetratelabs/wazero
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

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-24/wasi-sdk-24.0-x86_64-linux.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_118/binaryen-version_118-x86_64-linux.tar.gz"
+  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_119/binaryen-version_119-x86_64-linux.tar.gz"
 elif [[ "$OSTYPE" == "darwin"* ]]; then
   WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-24/wasi-sdk-24.0-x86_64-macos.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_118/binaryen-version_118-x86_64-macos.tar.gz"
+  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_119/binaryen-version_119-x86_64-macos.tar.gz"
 elif [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" ]]; then
   WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-24/wasi-sdk-24.0-x86_64-windows.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_118/binaryen-version_118-x86_64-windows.tar.gz"
+  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_119/binaryen-version_119-x86_64-windows.tar.gz"
 fi
 
 # Download tools

.github/workflows/test.yml

@@ -36,7 +36,7 @@ jobs:
       run: go mod verify
 
     - name: Vet
-      run: go vet -tags vet ./...
+      run: go vet ./...
 
     - name: Build
       run: go build -v ./...
@@ -153,6 +153,9 @@ jobs:
     - name: Test riscv64 (interpreter)
       run: GOARCH=riscv64 go test -v -short ./...
 
+    - name: Test ppc64le (interpreter)
+      run: GOARCH=ppc64le go test -v -short ./...
+
     - name: Test s390x (big-endian, z/OS demo)
       run: GOARCH=s390x go test -v -short -tags sqlite3_flock ./...
 

README.md

@@ -10,7 +10,21 @@ as well as direct access to most of the [C SQLite API](https://sqlite.org/cintro
 
 It wraps a [Wasm](https://webassembly.org/) [build](embed/) of SQLite,
 and uses [wazero](https://wazero.io/) as the runtime.\
-Go, wazero and [`x/sys`](https://pkg.go.dev/golang.org/x/sys) are the _only_ runtime dependencies [^1].
+Go, wazero and [`x/sys`](https://pkg.go.dev/golang.org/x/sys) are the _only_ runtime dependencies.
+
+### Getting started
+
+Using the [`database/sql`](https://pkg.go.dev/database/sql) driver:
+```go
+
+import "database/sql"
+import _ "github.com/ncruces/go-sqlite3/driver"
+import _ "github.com/ncruces/go-sqlite3/embed"
+
+var version string
+db, _ := sql.Open("sqlite3", "file:demo.db")
+db.QueryRow(`SELECT sqlite_version()`).Scan(&version)
+```
 
 ### Packages
 
@@ -35,6 +49,8 @@ Go, wazero and [`x/sys`](https://pkg.go.dev/golang.org/x/sys) are the _only_ run
   simplifies [incremental BLOB I/O](https://sqlite.org/c3ref/blob_open.html).
 - [`github.com/ncruces/go-sqlite3/ext/bloom`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/bloom)
   provides a [Bloom filter](https://github.com/nalgeon/sqlean/issues/27#issuecomment-1002267134) virtual table.
+- [`github.com/ncruces/go-sqlite3/ext/closure`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/closure)
+  provides a transitive closure virtual table.
 - [`github.com/ncruces/go-sqlite3/ext/csv`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/csv)
   reads [comma-separated values](https://sqlite.org/csv.html).
 - [`github.com/ncruces/go-sqlite3/ext/fileio`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/fileio)
@@ -94,7 +110,7 @@ It also benefits greatly from [SQLite's](https://sqlite.org/testing.html) and
 [wazero's](https://tetrate.io/blog/introducing-wazero-from-tetrate/#:~:text=Rock%2Dsolid%20test%20approach) thorough testing.
 
 Every commit is [tested](https://github.com/ncruces/go-sqlite3/wiki/Test-matrix) on
-Linux (amd64/arm64/386/riscv64/s390x), macOS (amd64/arm64),
+Linux (amd64/arm64/386/riscv64/ppc64le/s390x), macOS (amd64/arm64),
 Windows (amd64), FreeBSD (amd64), OpenBSD (amd64), NetBSD (amd64),
 illumos (amd64), and Solaris (amd64).
 
@@ -114,7 +130,4 @@ The Wasm and VFS layers are also tested by running SQLite's
 - [`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)
-
-[^1]: anything else you find in `go.mod` is either a test dependency,
-      or needed by one of the extensions.
+- [`github.com/zombiezen/go-sqlite`](https://pkg.go.dev/github.com/zombiezen/go-sqlite)

blob.go

@@ -21,6 +21,8 @@ type Blob struct {
 	bytes  int64
 	offset int64
 	handle uint32
+	bufptr uint32
+	buflen int64
 }
 
 var _ io.ReadWriteSeeker = &Blob{}
@@ -29,7 +31,6 @@ 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) {
-	c.checkInterrupt()
 	defer c.arena.mark()()
 	blobPtr := c.arena.new(ptrlen)
 	dbPtr := c.arena.string(db)
@@ -41,6 +42,7 @@ func (c *Conn) OpenBlob(db, table, column string, row int64, write bool) (*Blob,
 		flags = 1
 	}
 
+	c.checkInterrupt(c.handle)
 	r := c.call("sqlite3_blob_open", uint64(c.handle),
 		uint64(dbPtr), uint64(tablePtr), uint64(columnPtr),
 		uint64(row), flags, uint64(blobPtr))
@@ -66,7 +68,7 @@ func (b *Blob) Close() error {
 	}
 
 	r := b.c.call("sqlite3_blob_close", uint64(b.handle))
-
+	b.c.free(b.bufptr)
 	b.handle = 0
 	return b.c.error(r)
 }
@@ -86,17 +88,18 @@ func (b *Blob) Read(p []byte) (n int, err error) {
 		return 0, io.EOF
 	}
 
-	avail := b.bytes - b.offset
 	want := int64(len(p))
+	avail := b.bytes - b.offset
 	if want > avail {
 		want = avail
 	}
-
-	defer b.c.arena.mark()()
-	ptr := b.c.arena.new(uint64(want))
+	if want > b.buflen {
+		b.bufptr = b.c.realloc(b.bufptr, uint64(want))
+		b.buflen = want
+	}
 
 	r := b.c.call("sqlite3_blob_read", uint64(b.handle),
-		uint64(ptr), uint64(want), uint64(b.offset))
+		uint64(b.bufptr), uint64(want), uint64(b.offset))
 	err = b.c.error(r)
 	if err != nil {
 		return 0, err
@@ -106,7 +109,7 @@ func (b *Blob) Read(p []byte) (n int, err error) {
 		err = io.EOF
 	}
 
-	copy(p, util.View(b.c.mod, ptr, uint64(want)))
+	copy(p, util.View(b.c.mod, b.bufptr, uint64(want)))
 	return int(want), err
 }
 
@@ -123,19 +126,20 @@ func (b *Blob) WriteTo(w io.Writer) (n int64, err error) {
 	if want > avail {
 		want = avail
 	}
-
-	defer b.c.arena.mark()()
-	ptr := b.c.arena.new(uint64(want))
+	if want > b.buflen {
+		b.bufptr = b.c.realloc(b.bufptr, uint64(want))
+		b.buflen = want
+	}
 
 	for want > 0 {
 		r := b.c.call("sqlite3_blob_read", uint64(b.handle),
-			uint64(ptr), uint64(want), uint64(b.offset))
+			uint64(b.bufptr), uint64(want), uint64(b.offset))
 		err = b.c.error(r)
 		if err != nil {
 			return n, err
 		}
 
-		mem := util.View(b.c.mod, ptr, uint64(want))
+		mem := util.View(b.c.mod, b.bufptr, uint64(want))
 		m, err := w.Write(mem[:want])
 		b.offset += int64(m)
 		n += int64(m)
@@ -159,11 +163,15 @@ func (b *Blob) WriteTo(w io.Writer) (n int64, err error) {
 //
 // https://sqlite.org/c3ref/blob_write.html
 func (b *Blob) Write(p []byte) (n int, err error) {
-	defer b.c.arena.mark()()
-	ptr := b.c.arena.bytes(p)
+	want := int64(len(p))
+	if want > b.buflen {
+		b.bufptr = b.c.realloc(b.bufptr, uint64(want))
+		b.buflen = want
+	}
+	util.WriteBytes(b.c.mod, b.bufptr, p)
 
 	r := b.c.call("sqlite3_blob_write", uint64(b.handle),
-		uint64(ptr), uint64(len(p)), uint64(b.offset))
+		uint64(b.bufptr), uint64(want), uint64(b.offset))
 	err = b.c.error(r)
 	if err != nil {
 		return 0, err
@@ -187,16 +195,17 @@ func (b *Blob) ReadFrom(r io.Reader) (n int64, err error) {
 	if want < 1 {
 		want = 1
 	}
-
-	defer b.c.arena.mark()()
-	ptr := b.c.arena.new(uint64(want))
+	if want > b.buflen {
+		b.bufptr = b.c.realloc(b.bufptr, uint64(want))
+		b.buflen = want
+	}
 
 	for {
-		mem := util.View(b.c.mod, ptr, uint64(want))
+		mem := util.View(b.c.mod, b.bufptr, uint64(want))
 		m, err := r.Read(mem[:want])
 		if m > 0 {
 			r := b.c.call("sqlite3_blob_write", uint64(b.handle),
-				uint64(ptr), uint64(m), uint64(b.offset))
+				uint64(b.bufptr), uint64(m), uint64(b.offset))
 			err := b.c.error(r)
 			if err != nil {
 				return n, err

config.go

@@ -284,7 +284,10 @@ func walCallback(ctx context.Context, mod api.Module, _, pDB, zSchema uint32, pa
 //
 // https://sqlite.org/c3ref/autovacuum_pages.html
 func (c *Conn) AutoVacuumPages(cb func(schema string, dbPages, freePages, bytesPerPage uint) uint) error {
-	funcPtr := util.AddHandle(c.ctx, cb)
+	var funcPtr uint32
+	if cb != nil {
+		funcPtr = util.AddHandle(c.ctx, cb)
+	}
 	r := c.call("sqlite3_autovacuum_pages_go", uint64(c.handle), uint64(funcPtr))
 	return c.error(r)
 }
@@ -294,3 +297,17 @@ func autoVacuumCallback(ctx context.Context, mod api.Module, pApp, zSchema, nDbP
 	schema := util.ReadString(mod, zSchema, _MAX_NAME)
 	return uint32(fn(schema, uint(nDbPage), uint(nFreePage), uint(nBytePerPage)))
 }
+
+// SoftHeapLimit imposes a soft limit on heap size.
+//
+// https://sqlite.org/c3ref/hard_heap_limit64.html
+func (c *Conn) SoftHeapLimit(n int64) int64 {
+	return int64(c.call("sqlite3_soft_heap_limit64", uint64(n)))
+}
+
+// HardHeapLimit imposes a hard limit on heap size.
+//
+// https://sqlite.org/c3ref/hard_heap_limit64.html
+func (c *Conn) HardHeapLimit(n int64) int64 {
+	return int64(c.call("sqlite3_hard_heap_limit64", uint64(n)))
+}

conn.go

@@ -23,7 +23,8 @@ type Conn struct {
 	interrupt  context.Context
 	pending    *Stmt
 	stmts      []*Stmt
-	busy       func(int) bool
+	timer      *time.Timer
+	busy       func(context.Context, int) bool
 	log        func(xErrorCode, string)
 	collation  func(*Conn, string)
 	wal        func(*Conn, string, int) error
@@ -37,14 +38,20 @@ type Conn struct {
 	handle uint32
 }
 
-// Open calls [OpenFlags] with [OPEN_READWRITE], [OPEN_CREATE], [OPEN_URI] and [OPEN_NOFOLLOW].
+// Open calls [OpenFlags] with [OPEN_READWRITE], [OPEN_CREATE] and [OPEN_URI].
 func Open(filename string) (*Conn, error) {
-	return newConn(filename, OPEN_READWRITE|OPEN_CREATE|OPEN_URI|OPEN_NOFOLLOW)
+	return newConn(context.Background(), filename, OPEN_READWRITE|OPEN_CREATE|OPEN_URI)
+}
+
+// OpenContext is like [Open] but includes a context,
+// which is used to interrupt the process of opening the connectiton.
+func OpenContext(ctx context.Context, filename string) (*Conn, error) {
+	return newConn(ctx, filename, OPEN_READWRITE|OPEN_CREATE|OPEN_URI)
 }
 
 // OpenFlags opens an SQLite database file as specified by the filename argument.
 //
-// If none of the required flags is used, a combination of [OPEN_READWRITE] and [OPEN_CREATE] is used.
+// If none of the required flags are used, a combination of [OPEN_READWRITE] and [OPEN_CREATE] is used.
 // If a URI filename is used, PRAGMA statements to execute can be specified using "_pragma":
 //
 //	sqlite3.Open("file:demo.db?_pragma=busy_timeout(10000)")
@@ -54,25 +61,33 @@ func OpenFlags(filename string, flags OpenFlag) (*Conn, error) {
 	if flags&(OPEN_READONLY|OPEN_READWRITE|OPEN_CREATE) == 0 {
 		flags |= OPEN_READWRITE | OPEN_CREATE
 	}
-	return newConn(filename, flags)
+	return newConn(context.Background(), filename, flags)
 }
 
 type connKey struct{}
 
-func newConn(filename string, flags OpenFlag) (conn *Conn, err error) {
-	sqlite, err := instantiateSQLite()
+func newConn(ctx context.Context, filename string, flags OpenFlag) (res *Conn, _ error) {
+	err := ctx.Err()
+	if err != nil {
+		return nil, err
+	}
+
+	c := &Conn{interrupt: ctx}
+	c.sqlite, err = instantiateSQLite()
 	if err != nil {
 		return nil, err
 	}
 	defer func() {
-		if conn == nil {
-			sqlite.close()
+		if res == nil {
+			c.Close()
+			c.sqlite.close()
+		} else {
+			c.interrupt = context.Background()
 		}
 	}()
 
-	c := &Conn{sqlite: sqlite}
-	c.arena = c.newArena(1024)
 	c.ctx = context.WithValue(c.ctx, connKey{}, c)
+	c.arena = c.newArena(1024)
 	c.handle, err = c.openDB(filename, flags)
 	if err == nil {
 		err = initExtensions(c)
@@ -97,6 +112,7 @@ func (c *Conn) openDB(filename string, flags OpenFlag) (uint32, error) {
 		return 0, err
 	}
 
+	c.call("sqlite3_progress_handler_go", uint64(handle), 100)
 	if flags|OPEN_URI != 0 && strings.HasPrefix(filename, "file:") {
 		var pragmas strings.Builder
 		if _, after, ok := strings.Cut(filename, "?"); ok {
@@ -108,6 +124,7 @@ func (c *Conn) openDB(filename string, flags OpenFlag) (uint32, error) {
 			}
 		}
 		if pragmas.Len() != 0 {
+			c.checkInterrupt(handle)
 			pragmaPtr := c.arena.string(pragmas.String())
 			r := c.call("sqlite3_exec", uint64(handle), uint64(pragmaPtr), 0, 0, 0)
 			if err := c.sqlite.error(r, handle, pragmas.String()); err != nil {
@@ -117,7 +134,6 @@ func (c *Conn) openDB(filename string, flags OpenFlag) (uint32, error) {
 			}
 		}
 	}
-	c.call("sqlite3_progress_handler_go", uint64(handle), 100)
 	return handle, nil
 }
 
@@ -159,10 +175,10 @@ func (c *Conn) Close() error {
 //
 // https://sqlite.org/c3ref/exec.html
 func (c *Conn) Exec(sql string) error {
-	c.checkInterrupt()
 	defer c.arena.mark()()
 	sqlPtr := c.arena.string(sql)
 
+	c.checkInterrupt(c.handle)
 	r := c.call("sqlite3_exec", uint64(c.handle), uint64(sqlPtr), 0, 0, 0)
 	return c.error(r, sql)
 }
@@ -300,8 +316,7 @@ func (c *Conn) ReleaseMemory() error {
 	return c.error(r)
 }
 
-// GetInterrupt gets the context set with [Conn.SetInterrupt],
-// or nil if none was set.
+// GetInterrupt gets the context set with [Conn.SetInterrupt].
 func (c *Conn) GetInterrupt() context.Context {
 	return c.interrupt
 }
@@ -321,9 +336,11 @@ func (c *Conn) GetInterrupt() context.Context {
 //
 // https://sqlite.org/c3ref/interrupt.html
 func (c *Conn) SetInterrupt(ctx context.Context) (old context.Context) {
-	// Is it the same context?
-	if ctx == c.interrupt {
-		return ctx
+	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
@@ -332,32 +349,29 @@ func (c *Conn) SetInterrupt(ctx context.Context) (old context.Context) {
 		defer c.arena.mark()()
 		stmtPtr := c.arena.new(ptrlen)
 		loopPtr := c.arena.string(`WITH RECURSIVE c(x) AS (VALUES(0) UNION ALL SELECT x FROM c) SELECT x FROM c`)
-		c.call("sqlite3_prepare_v3", uint64(c.handle), uint64(loopPtr), math.MaxUint64, 0, uint64(stmtPtr), 0)
+		c.call("sqlite3_prepare_v3", uint64(c.handle), uint64(loopPtr), math.MaxUint64,
+			uint64(PREPARE_PERSISTENT), uint64(stmtPtr), 0)
 		c.pending = &Stmt{c: c}
 		c.pending.handle = util.ReadUint32(c.mod, stmtPtr)
 	}
 
-	old = c.interrupt
-	c.interrupt = ctx
-
-	if old != nil && old.Done() != nil && (ctx == nil || ctx.Err() == nil) {
+	if old.Done() != nil && ctx.Err() == nil {
 		c.pending.Reset()
 	}
-	if ctx != nil && ctx.Done() != nil {
+	if ctx.Done() != nil {
 		c.pending.Step()
 	}
 	return old
 }
 
-func (c *Conn) checkInterrupt() {
-	if c.interrupt != nil && c.interrupt.Err() != nil {
-		c.call("sqlite3_interrupt", uint64(c.handle))
+func (c *Conn) checkInterrupt(handle uint32) {
+	if c.interrupt.Err() != nil {
+		c.call("sqlite3_interrupt", uint64(handle))
 	}
 }
 
-func progressCallback(ctx context.Context, mod api.Module, pDB uint32) (interrupt uint32) {
-	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB &&
-		c.interrupt != nil && c.interrupt.Err() != nil {
+func progressCallback(ctx context.Context, mod api.Module, _ uint32) (interrupt uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.interrupt.Err() != nil {
 		interrupt = 1
 	}
 	return interrupt
@@ -372,9 +386,8 @@ func (c *Conn) BusyTimeout(timeout time.Duration) error {
 	return c.error(r)
 }
 
-func timeoutCallback(ctx context.Context, mod api.Module, pDB uint32, count, tmout int32) (retry uint32) {
-	if c, ok := ctx.Value(connKey{}).(*Conn); ok &&
-		(c.interrupt == nil || c.interrupt.Err() == nil) {
+func timeoutCallback(ctx context.Context, mod api.Module, count, tmout int32) (retry uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.interrupt.Err() == nil {
 		const delays = "\x01\x02\x05\x0a\x0f\x14\x19\x19\x19\x32\x32\x64"
 		const totals = "\x00\x01\x03\x08\x12\x21\x35\x4e\x67\x80\xb2\xe4"
 		const ndelay = int32(len(delays) - 1)
@@ -389,17 +402,31 @@ func timeoutCallback(ctx context.Context, mod api.Module, pDB uint32, count, tmo
 		}
 
 		if delay = min(delay, tmout-prior); delay > 0 {
-			time.Sleep(time.Duration(delay) * time.Millisecond)
-			retry = 1
+			delay := time.Duration(delay) * time.Millisecond
+			if c.interrupt.Done() == nil {
+				time.Sleep(delay)
+				return 1
+			}
+			if c.timer == nil {
+				c.timer = time.NewTimer(delay)
+			} else {
+				c.timer.Reset(delay)
+			}
+			select {
+			case <-c.interrupt.Done():
+				c.timer.Stop()
+			case <-c.timer.C:
+				return 1
+			}
 		}
 	}
-	return retry
+	return 0
 }
 
 // BusyHandler registers a callback to handle [BUSY] errors.
 //
 // https://sqlite.org/c3ref/busy_handler.html
-func (c *Conn) BusyHandler(cb func(count int) (retry bool)) error {
+func (c *Conn) BusyHandler(cb func(ctx context.Context, count int) (retry bool)) error {
 	var enable uint64
 	if cb != nil {
 		enable = 1
@@ -413,9 +440,12 @@ func (c *Conn) BusyHandler(cb func(count int) (retry bool)) error {
 }
 
 func busyCallback(ctx context.Context, mod api.Module, pDB uint32, count int32) (retry uint32) {
-	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.busy != nil &&
-		(c.interrupt == nil || c.interrupt.Err() == nil) {
-		if c.busy(int(count)) {
+	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)) {
 			retry = 1
 		}
 	}
@@ -492,9 +522,7 @@ func (c *Conn) stmtsIter(yield func(*Stmt) bool) {
 
 // DriverConn is implemented by the SQLite [database/sql] driver connection.
 //
-// It can be used to access SQLite features like [online backup].
-//
-// [online backup]: https://sqlite.org/backup.html
+// Deprecated: use [github.com/ncruces/go-sqlite3/driver.Conn] instead.
 type DriverConn interface {
 	Raw() *Conn
 }

conn_iter.go

@@ -1,4 +1,4 @@
-//go:build (go1.23 || goexperiment.rangefunc) && !vet
+//go:build go1.23
 
 package sqlite3
 

conn_old.go

@@ -1,4 +1,4 @@
-//go:build !(go1.23 || goexperiment.rangefunc) || vet
+//go:build !go1.23
 
 package sqlite3
 

const.go

@@ -7,13 +7,10 @@ const (
 	_ROW  = 100 /* sqlite3_step() has another row ready */
 	_DONE = 101 /* sqlite3_step() has finished executing */
 
-	_UTF8 = 1
-
-	_MAX_NAME            = 1e6 // Self-imposed limit for most NUL terminated strings.
-	_MAX_LENGTH          = 1e9
-	_MAX_SQL_LENGTH      = 1e9
-	_MAX_ALLOCATION_SIZE = 0x7ffffeff
-	_MAX_FUNCTION_ARG    = 100
+	_MAX_NAME         = 1e6 // Self-imposed limit for most NUL terminated strings.
+	_MAX_LENGTH       = 1e9
+	_MAX_SQL_LENGTH   = 1e9
+	_MAX_FUNCTION_ARG = 100
 
 	ptrlen = 4
 )

context.go

@@ -84,9 +84,8 @@ func (ctx Context) ResultFloat(value float64) {
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultText(value string) {
 	ptr := ctx.c.newString(value)
-	ctx.c.call("sqlite3_result_text64",
-		uint64(ctx.handle), uint64(ptr), uint64(len(value)),
-		uint64(ctx.c.freer), _UTF8)
+	ctx.c.call("sqlite3_result_text_go",
+		uint64(ctx.handle), uint64(ptr), uint64(len(value)))
 }
 
 // ResultRawText sets the text result of the function to a []byte.
@@ -94,9 +93,8 @@ func (ctx Context) ResultText(value string) {
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultRawText(value []byte) {
 	ptr := ctx.c.newBytes(value)
-	ctx.c.call("sqlite3_result_text64",
-		uint64(ctx.handle), uint64(ptr), uint64(len(value)),
-		uint64(ctx.c.freer), _UTF8)
+	ctx.c.call("sqlite3_result_text_go",
+		uint64(ctx.handle), uint64(ptr), uint64(len(value)))
 }
 
 // ResultBlob sets the result of the function to a []byte.
@@ -105,9 +103,8 @@ func (ctx Context) ResultRawText(value []byte) {
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultBlob(value []byte) {
 	ptr := ctx.c.newBytes(value)
-	ctx.c.call("sqlite3_result_blob64",
-		uint64(ctx.handle), uint64(ptr), uint64(len(value)),
-		uint64(ctx.c.freer))
+	ctx.c.call("sqlite3_result_blob_go",
+		uint64(ctx.handle), uint64(ptr), uint64(len(value)))
 }
 
 // ResultZeroBlob sets the result of the function to a zero-filled, length n BLOB.
@@ -154,9 +151,8 @@ func (ctx Context) resultRFC3339Nano(value time.Time) {
 	buf := util.View(ctx.c.mod, ptr, maxlen)
 	buf = value.AppendFormat(buf[:0], time.RFC3339Nano)
 
-	ctx.c.call("sqlite3_result_text64",
-		uint64(ctx.handle), uint64(ptr), uint64(len(buf)),
-		uint64(ctx.c.freer), _UTF8)
+	ctx.c.call("sqlite3_result_text_go",
+		uint64(ctx.handle), uint64(ptr), uint64(len(buf)))
 }
 
 // ResultPointer sets the result of the function to NULL, just like [Context.ResultNull],

driver/driver.go

@@ -40,14 +40,14 @@
 // When using a custom time struct, you'll have to implement
 // [database/sql/driver.Valuer] and [database/sql.Scanner].
 //
-// The Value method should ideally serialise to a time [format] supported by SQLite.
+// The Value method should ideally encode to a time [format] supported by SQLite.
 // This ensures SQL date and time functions work as they should,
 // and that your schema works with other SQLite tools.
 // [sqlite3.TimeFormat.Encode] may help.
 //
 // The Scan method needs to take into account that the value it receives can be of differing types.
 // It can already be a [time.Time], if the driver decoded the value according to "_timefmt" rules.
-// Or it can be a: string, int64, float64, []byte, nil,
+// Or it can be a: string, int64, float64, []byte, or nil,
 // depending on the column type and what whoever wrote the value.
 // [sqlite3.TimeFormat.Decode] may help.
 //
@@ -130,6 +130,11 @@ type SQLite struct {
 	term func(*sqlite3.Conn) error
 }
 
+var (
+	// Ensure these interfaces are implemented:
+	_ driver.DriverContext = &SQLite{}
+)
+
 // Open implements [database/sql/driver.Driver].
 func (d *SQLite) Open(name string) (driver.Conn, error) {
 	c, err := d.newConnector(name)
@@ -197,19 +202,19 @@ func (n *connector) Driver() driver.Driver {
 	return n.driver
 }
 
-func (n *connector) Connect(ctx context.Context) (_ driver.Conn, err error) {
+func (n *connector) Connect(ctx context.Context) (res driver.Conn, err error) {
 	c := &conn{
 		txLock:  n.txLock,
 		tmRead:  n.tmRead,
 		tmWrite: n.tmWrite,
 	}
 
-	c.Conn, err = sqlite3.Open(n.name)
+	c.Conn, err = sqlite3.OpenContext(ctx, n.name)
 	if err != nil {
 		return nil, err
 	}
 	defer func() {
-		if err != nil {
+		if res == nil {
 			c.Close()
 		}
 	}()
@@ -234,6 +239,7 @@ func (n *connector) Connect(ctx context.Context) (_ driver.Conn, err error) {
 		if err != nil {
 			return nil, err
 		}
+		defer s.Close()
 		if s.Step() && s.ColumnBool(0) {
 			c.readOnly = '1'
 		} else {
@@ -255,6 +261,35 @@ func (n *connector) Connect(ctx context.Context) (_ driver.Conn, err error) {
 	return c, nil
 }
 
+// Conn is implemented by the SQLite [database/sql] driver connections.
+//
+// It can be used to access SQLite features like [online backup]:
+//
+//	db, err := driver.Open("temp.db")
+//	if err != nil {
+//		log.Fatal(err)
+//	}
+//	defer db.Close()
+//
+//	conn, err := db.Conn(context.TODO())
+//	if err != nil {
+//		log.Fatal(err)
+//	}
+//
+//	err = conn.Raw(func(driverConn any) error {
+//		conn := driverConn.(driver.Conn)
+//		return conn.Raw().Backup("main", "backup.db")
+//	})
+//	if err != nil {
+//		log.Fatal(err)
+//	}
+//
+// [online backup]: https://sqlite.org/backup.html
+type Conn interface {
+	Raw() *sqlite3.Conn
+	driver.Conn
+}
+
 type conn struct {
 	*sqlite3.Conn
 	txLock   string
@@ -266,10 +301,10 @@ type conn struct {
 
 var (
 	// Ensure these interfaces are implemented:
+	_ Conn                      = &conn{}
+	_ driver.ConnBeginTx        = &conn{}
 	_ driver.ConnPrepareContext = &conn{}
 	_ driver.ExecerContext      = &conn{}
-	_ driver.ConnBeginTx        = &conn{}
-	_ sqlite3.DriverConn        = &conn{}
 )
 
 func (c *conn) Raw() *sqlite3.Conn {
@@ -432,6 +467,7 @@ func (s *stmt) ExecContext(ctx context.Context, args []driver.NamedValue) (drive
 	defer s.Stmt.Conn().SetInterrupt(old)
 
 	err = s.Stmt.Exec()
+	s.Stmt.ClearBindings()
 	if err != nil {
 		return nil, err
 	}
@@ -454,7 +490,7 @@ func (s *stmt) setupBindings(args []driver.NamedValue) (err error) {
 		if arg.Name == "" {
 			ids = append(ids, arg.Ordinal)
 		} else {
-			for _, prefix := range []string{":", "@", "$"} {
+			for _, prefix := range [...]string{":", "@", "$"} {
 				if id := s.Stmt.BindIndex(prefix + arg.Name); id != 0 {
 					ids = append(ids, id)
 				}
@@ -488,9 +524,9 @@ func (s *stmt) setupBindings(args []driver.NamedValue) (err error) {
 			default:
 				panic(util.AssertErr())
 			}
-		}
-		if err != nil {
-			return err
+			if err != nil {
+				return err
+			}
 		}
 	}
 	return nil
@@ -544,8 +580,15 @@ type rows struct {
 	*stmt
 	names []string
 	types []string
+	nulls []bool
 }
 
+var (
+	// Ensure these interfaces are implemented:
+	_ driver.RowsColumnTypeDatabaseTypeName = &rows{}
+	_ driver.RowsColumnTypeNullable         = &rows{}
+)
+
 func (r *rows) Close() error {
 	r.Stmt.ClearBindings()
 	return r.Stmt.Reset()
@@ -554,27 +597,48 @@ func (r *rows) Close() error {
 func (r *rows) Columns() []string {
 	if r.names == nil {
 		count := r.Stmt.ColumnCount()
-		r.names = make([]string, count)
-		for i := range r.names {
-			r.names[i] = r.Stmt.ColumnName(i)
+		names := make([]string, count)
+		for i := range names {
+			names[i] = r.Stmt.ColumnName(i)
 		}
+		r.names = names
 	}
 	return r.names
 }
 
+func (r *rows) loadTypes() {
+	if r.nulls == nil {
+		count := r.Stmt.ColumnCount()
+		nulls := make([]bool, count)
+		types := make([]string, count)
+		for i := range nulls {
+			if col := r.Stmt.ColumnOriginName(i); col != "" {
+				types[i], _, nulls[i], _, _, _ = r.Stmt.Conn().TableColumnMetadata(
+					r.Stmt.ColumnDatabaseName(i),
+					r.Stmt.ColumnTableName(i),
+					col)
+			}
+		}
+		r.nulls = nulls
+		r.types = types
+	}
+}
+
 func (r *rows) declType(index int) string {
 	if r.types == nil {
 		count := r.Stmt.ColumnCount()
-		r.types = make([]string, count)
-		for i := range r.types {
-			r.types[i] = strings.ToUpper(r.Stmt.ColumnDeclType(i))
+		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 {
-	decltype := r.declType(index)
+	r.loadTypes()
+	decltype := r.types[index]
 	if len := len(decltype); len > 0 && decltype[len-1] == ')' {
 		if i := strings.LastIndexByte(decltype, '('); i >= 0 {
 			decltype = decltype[:i]
@@ -583,6 +647,14 @@ func (r *rows) ColumnTypeDatabaseTypeName(index int) string {
 	return strings.TrimSpace(decltype)
 }
 
+func (r *rows) ColumnTypeNullable(index int) (nullable, ok bool) {
+	r.loadTypes()
+	if r.nulls[index] {
+		return false, true
+	}
+	return true, false
+}
+
 func (r *rows) Next(dest []driver.Value) error {
 	old := r.Stmt.Conn().SetInterrupt(r.ctx)
 	defer r.Stmt.Conn().SetInterrupt(old)
@@ -599,27 +671,23 @@ func (r *rows) Next(dest []driver.Value) error {
 	for i := range dest {
 		if t, ok := r.decodeTime(i, dest[i]); ok {
 			dest[i] = t
-			continue
-		}
-		if s, ok := dest[i].(string); ok {
-			t, ok := maybeTime(s)
-			if ok {
-				dest[i] = t
-			}
 		}
 	}
 	return err
 }
 
 func (r *rows) decodeTime(i int, v any) (_ time.Time, ok bool) {
-	switch r.tmRead {
-	case sqlite3.TimeFormatDefault, time.RFC3339Nano:
-		// handled by maybeTime
-		return
-	}
-	switch v.(type) {
-	case int64, float64, string:
+	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 {
+			break
+		}
+		t, ok := maybeTime(v)
+		if ok {
+			return t, true
+		}
 	default:
 		return
 	}

driver/example2_test.go

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

driver/example_test.go

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

embed/README.md

@@ -9,6 +9,7 @@ The following optional features are compiled in:
 - [JSON](https://sqlite.org/json1.html)
 - [R*Tree](https://sqlite.org/rtree.html)
 - [GeoPoly](https://sqlite.org/geopoly.html)
+- [Spellfix1](https://sqlite.org/spellfix1.html)
 - [soundex](https://sqlite.org/lang_corefunc.html#soundex)
 - [stat4](https://sqlite.org/compile.html#enable_stat4)
 - [base64](https://github.com/sqlite/sqlite/blob/master/ext/misc/base64.c)

embed/bcw2/.gitignore

@@ -0,0 +1,2 @@
+build/
+sqlite/

embed/bcw2/build.sh

@@ -33,6 +33,7 @@ mv sqlite/ext/misc/decimal.c    build/ext/
 mv sqlite/ext/misc/ieee754.c    build/ext/
 mv sqlite/ext/misc/regexp.c     build/ext/
 mv sqlite/ext/misc/series.c     build/ext/
+mv sqlite/ext/misc/spellfix.c   build/ext/
 mv sqlite/ext/misc/uint.c       build/ext/
 
 cd build
@@ -44,7 +45,7 @@ cd ~-
 	-o bcw2.wasm "build/main.c" \
 	-I"build" \
 	-mexec-model=reactor \
-	-matomics -msimd128 -mmutable-globals \
+	-matomics -msimd128 -mmutable-globals -mmultivalue \
 	-mbulk-memory -mreference-types \
 	-mnontrapping-fptoint -msign-ext \
 	-fno-stack-protector -fno-stack-clash-protection \

embed/bcw2/init.go

@@ -6,7 +6,7 @@
 //	import _ "github.com/ncruces/go-sqlite3/embed/bcw2"
 //
 // [BEGIN CONCURRENT]: https://sqlite.org/src/doc/begin-concurrent/doc/begin_concurrent.md
-// [Wal2]: https://www.sqlite.org/cgi/src/doc/wal2/doc/wal2.md
+// [Wal2]: https://sqlite.org/cgi/src/doc/wal2/doc/wal2.md
 package bcw2
 
 import (

embed/build.sh

@@ -14,7 +14,7 @@ trap 'rm -f sqlite3.tmp' EXIT
 	-o sqlite3.wasm "$ROOT/sqlite3/main.c" \
 	-I"$ROOT/sqlite3" \
 	-mexec-model=reactor \
-	-matomics -msimd128 -mmutable-globals \
+	-matomics -msimd128 -mmutable-globals -mmultivalue \
 	-mbulk-memory -mreference-types \
 	-mnontrapping-fptoint -msign-ext \
 	-fno-stack-protector -fno-stack-clash-protection \

embed/exports.txt

@@ -1,7 +1,4 @@
 aligned_alloc
-free
-malloc
-malloc_destructor
 sqlite3_anycollseq_init
 sqlite3_autovacuum_pages_go
 sqlite3_backup_finish
@@ -9,7 +6,7 @@ sqlite3_backup_init
 sqlite3_backup_pagecount
 sqlite3_backup_remaining
 sqlite3_backup_step
-sqlite3_bind_blob64
+sqlite3_bind_blob_go
 sqlite3_bind_double
 sqlite3_bind_int64
 sqlite3_bind_null
@@ -17,7 +14,7 @@ sqlite3_bind_parameter_count
 sqlite3_bind_parameter_index
 sqlite3_bind_parameter_name
 sqlite3_bind_pointer_go
-sqlite3_bind_text64
+sqlite3_bind_text_go
 sqlite3_bind_value
 sqlite3_bind_zeroblob64
 sqlite3_blob_bytes
@@ -54,6 +51,7 @@ sqlite3_create_collation_go
 sqlite3_create_function_go
 sqlite3_create_module_go
 sqlite3_create_window_function_go
+sqlite3_data_count
 sqlite3_database_file_object
 sqlite3_db_cacheflush
 sqlite3_db_config
@@ -74,17 +72,21 @@ sqlite3_filename_database
 sqlite3_filename_journal
 sqlite3_filename_wal
 sqlite3_finalize
+sqlite3_free
 sqlite3_get_autocommit
 sqlite3_get_auxdata
+sqlite3_hard_heap_limit64
 sqlite3_interrupt
 sqlite3_last_insert_rowid
 sqlite3_limit
+sqlite3_malloc64
 sqlite3_open_v2
 sqlite3_overload_function
 sqlite3_prepare_v3
 sqlite3_progress_handler_go
+sqlite3_realloc64
 sqlite3_reset
-sqlite3_result_blob64
+sqlite3_result_blob_go
 sqlite3_result_double
 sqlite3_result_error
 sqlite3_result_error_code
@@ -93,13 +95,14 @@ sqlite3_result_error_toobig
 sqlite3_result_int64
 sqlite3_result_null
 sqlite3_result_pointer_go
-sqlite3_result_text64
+sqlite3_result_text_go
 sqlite3_result_value
 sqlite3_result_zeroblob64
 sqlite3_rollback_hook_go
 sqlite3_set_authorizer_go
 sqlite3_set_auxdata_go
 sqlite3_set_last_insert_rowid
+sqlite3_soft_heap_limit64
 sqlite3_step
 sqlite3_stmt_busy
 sqlite3_stmt_readonly

ext/blobio/blob.go

@@ -11,11 +11,11 @@ import (
 
 // Register registers the SQL functions:
 //
-//	readblob(schema, table, column, rowid, offset, n)
+//	readblob(schema, table, column, rowid, offset, n/writer)
 //
 // Reads n bytes of a blob, starting at offset.
 //
-//	writeblob(schema, table, column, rowid, offset, data)
+//	writeblob(schema, table, column, rowid, offset, data/reader)
 //
 // Writes data into a blob, at the given offset.
 //
@@ -27,6 +27,10 @@ import (
 // using [sqlite3.BindPointer] or [sqlite3.Pointer].
 // The optional args will be passed to the callback,
 // along with the [sqlite3.Blob] handle.
+// The [sqlite3.Blob] handle is only valid during
+// the execution of the callback. Callers cannot
+// read or write to the handle after the callback
+// exits.
 //
 // https://sqlite.org/c3ref/blob.html
 func Register(db *sqlite3.Conn) error {
@@ -52,19 +56,24 @@ func readblob(ctx sqlite3.Context, arg ...sqlite3.Value) {
 		return // notest
 	}
 
-	n := arg[5].Int64()
-	if n <= 0 {
-		return
+	if p, ok := arg[5].Pointer().(io.Writer); ok {
+		var n int64
+		n, err = blob.WriteTo(p)
+		ctx.ResultInt64(n)
+	} else {
+		n := arg[5].Int64()
+		if n <= 0 {
+			return
+		}
+		buf := make([]byte, n)
+		_, err = io.ReadFull(blob, buf)
+		ctx.ResultBlob(buf)
 	}
-	buf := make([]byte, n)
-
-	_, err = io.ReadFull(blob, buf)
 	if err != nil {
 		ctx.ResultError(err)
 		return // notest
 	}
 
-	ctx.ResultBlob(buf)
 	setAuxBlob(ctx, blob, false)
 }
 
@@ -82,7 +91,9 @@ func writeblob(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	}
 
 	if p, ok := arg[5].Pointer().(io.Reader); ok {
-		_, err = blob.ReadFrom(p)
+		var n int64
+		n, err = blob.ReadFrom(p)
+		ctx.ResultInt64(n)
 	} else {
 		_, err = blob.Write(arg[5].RawBlob())
 	}

ext/blobio/blob_test.go

@@ -34,23 +34,26 @@ func Example() {
 	const message = "Hello BLOB!"
 
 	// Create the BLOB.
-	_, err = db.Exec(`INSERT INTO test VALUES (?)`, sqlite3.ZeroBlob(len(message)))
+	r, err := db.Exec(`INSERT INTO test VALUES (?)`, sqlite3.ZeroBlob(len(message)))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	id, err := r.LastInsertId()
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	// Write the BLOB.
-	_, err = db.Exec(`SELECT writeblob('main', 'test', 'col', last_insert_rowid(), 0, ?)`, message)
+	_, err = db.Exec(`SELECT writeblob('main', 'test', 'col', ?, 0, ?)`,
+		id, message)
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	// Read the BLOB.
-	_, err = db.Exec(`SELECT openblob('main', 'test', 'col', rowid, false, ?) FROM test`,
-		sqlite3.Pointer[blobio.OpenCallback](func(blob *sqlite3.Blob, _ ...sqlite3.Value) error {
-			_, err = blob.WriteTo(os.Stdout)
-			return err
-		}))
+	_, err = db.Exec(`SELECT readblob('main', 'test', 'col', ?, 0, ?)`,
+		id, sqlite3.Pointer(os.Stdout))
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -58,9 +61,10 @@ func Example() {
 	// Hello BLOB!
 }
 
-func init() {
+func TestMain(m *testing.M) {
 	sqlite3.AutoExtension(blobio.Register)
 	sqlite3.AutoExtension(array.Register)
+	m.Run()
 }
 
 func Test_readblob(t *testing.T) {

ext/bloom/bloom.go

@@ -34,7 +34,7 @@ type bloom struct {
 }
 
 func create(db *sqlite3.Conn, _, schema, table string, arg ...string) (_ *bloom, err error) {
-	t := bloom{
+	b := bloom{
 		db:      db,
 		schema:  schema,
 		storage: table + "_storage",
@@ -54,34 +54,40 @@ func create(db *sqlite3.Conn, _, schema, table string, arg ...string) (_ *bloom,
 	}
 
 	if len(arg) > 1 {
-		t.prob, err = strconv.ParseFloat(arg[1], 64)
+		b.prob, err = strconv.ParseFloat(arg[1], 64)
 		if err != nil {
 			return nil, err
 		}
-		if t.prob <= 0 || t.prob >= 1 {
+		if b.prob <= 0 || b.prob >= 1 {
 			return nil, util.ErrorString("bloom: probability must be in the range (0,1)")
 		}
 	} else {
-		t.prob = 0.01
+		b.prob = 0.01
 	}
 
 	if len(arg) > 2 {
-		t.hashes, err = strconv.Atoi(arg[2])
+		b.hashes, err = strconv.Atoi(arg[2])
 		if err != nil {
 			return nil, err
 		}
-		if t.hashes <= 0 {
+		if b.hashes <= 0 {
 			return nil, util.ErrorString("bloom: number of hash functions must be positive")
 		}
 	} else {
-		t.hashes = max(1, numHashes(t.prob))
+		b.hashes = max(1, numHashes(b.prob))
 	}
 
-	t.bytes = numBytes(nelem, t.prob)
+	b.bytes = numBytes(nelem, b.prob)
+
+	err = db.DeclareVTab(
+		`CREATE TABLE x(present, word HIDDEN NOT NULL PRIMARY KEY) WITHOUT ROWID`)
+	if err != nil {
+		return nil, err
+	}
 
 	err = db.Exec(fmt.Sprintf(
 		`CREATE TABLE %s.%s (data BLOB, p REAL, n INTEGER, m INTEGER, k INTEGER)`,
-		sqlite3.QuoteIdentifier(t.schema), sqlite3.QuoteIdentifier(t.storage)))
+		sqlite3.QuoteIdentifier(b.schema), sqlite3.QuoteIdentifier(b.storage)))
 	if err != nil {
 		return nil, err
 	}
@@ -92,23 +98,17 @@ func create(db *sqlite3.Conn, _, schema, table string, arg ...string) (_ *bloom,
 	err = db.Exec(fmt.Sprintf(
 		`INSERT INTO %s.%s (rowid, data, p, n, m, k)
 		 VALUES (1, zeroblob(%d), %f, %d, %d, %d)`,
-		sqlite3.QuoteIdentifier(t.schema), sqlite3.QuoteIdentifier(t.storage),
-		t.bytes, t.prob, nelem, 8*t.bytes, t.hashes))
+		sqlite3.QuoteIdentifier(b.schema), sqlite3.QuoteIdentifier(b.storage),
+		b.bytes, b.prob, nelem, 8*b.bytes, b.hashes))
 	if err != nil {
+		b.Destroy()
 		return nil, err
 	}
-
-	err = db.DeclareVTab(
-		`CREATE TABLE x(present, word HIDDEN NOT NULL PRIMARY KEY) WITHOUT ROWID`)
-	if err != nil {
-		t.Destroy()
-		return nil, err
-	}
-	return &t, nil
+	return &b, nil
 }
 
 func connect(db *sqlite3.Conn, _, schema, table string, arg ...string) (_ *bloom, err error) {
-	t := bloom{
+	b := bloom{
 		db:      db,
 		schema:  schema,
 		storage: table + "_storage",
@@ -122,7 +122,7 @@ func connect(db *sqlite3.Conn, _, schema, table string, arg ...string) (_ *bloom
 
 	load, _, err := db.Prepare(fmt.Sprintf(
 		`SELECT m/8, p, k FROM %s.%s WHERE rowid = 1`,
-		sqlite3.QuoteIdentifier(t.schema), sqlite3.QuoteIdentifier(t.storage)))
+		sqlite3.QuoteIdentifier(b.schema), sqlite3.QuoteIdentifier(b.storage)))
 	if err != nil {
 		return nil, err
 	}
@@ -135,10 +135,10 @@ func connect(db *sqlite3.Conn, _, schema, table string, arg ...string) (_ *bloom
 		return nil, sqlite3.CORRUPT_VTAB
 	}
 
-	t.bytes = load.ColumnInt64(0)
-	t.prob = load.ColumnFloat(1)
-	t.hashes = load.ColumnInt(2)
-	return &t, nil
+	b.bytes = load.ColumnInt64(0)
+	b.prob = load.ColumnFloat(1)
+	b.hashes = load.ColumnInt(2)
+	return &b, nil
 }
 
 func (b *bloom) Destroy() error {
@@ -198,10 +198,10 @@ func (t *bloom) Integrity(schema, table string, flags int) error {
 }
 
 func (b *bloom) BestIndex(idx *sqlite3.IndexInfo) error {
-	for n, cst := range idx.Constraint {
+	for i, cst := range idx.Constraint {
 		if cst.Usable && cst.Column == 1 &&
 			cst.Op == sqlite3.INDEX_CONSTRAINT_EQ {
-			idx.ConstraintUsage[n].ArgvIndex = 1
+			idx.ConstraintUsage[i].ArgvIndex = 1
 			idx.OrderByConsumed = true
 			idx.EstimatedRows = 1
 			idx.EstimatedCost = float64(b.hashes)
@@ -272,10 +272,6 @@ type cursor struct {
 }
 
 func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
-	if len(arg) != 1 {
-		return nil
-	}
-
 	c.eof = false
 	c.arg = &arg[0]
 	blob := arg[0].RawBlob()

ext/bloom/bloom_test.go

@@ -12,8 +12,9 @@ import (
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
-func init() {
+func TestMain(m *testing.M) {
 	sqlite3.AutoExtension(bloom.Register)
+	m.Run()
 }
 
 func TestRegister(t *testing.T) {

ext/closure/closure.go

@@ -0,0 +1,264 @@
+// Package closure provides a transitive closure virtual table.
+//
+// The transitive_closure virtual table finds the transitive closure of
+// a parent/child relationship in a real table.
+//
+// https://sqlite.org/src/doc/tip/ext/misc/closure.c
+package closure
+
+import (
+	"fmt"
+	"math"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/ncruces/go-sqlite3/util/vtabutil"
+)
+
+const (
+	_COL_ID           = 0
+	_COL_DEPTH        = 1
+	_COL_ROOT         = 2
+	_COL_TABLENAME    = 3
+	_COL_IDCOLUMN     = 4
+	_COL_PARENTCOLUMN = 5
+)
+
+// Register registers the transitive_closure virtual table:
+//
+//	CREATE VIRTUAL TABLE temp.closure USING transitive_closure;
+func Register(db *sqlite3.Conn) error {
+	return sqlite3.CreateModule(db, "transitive_closure", nil,
+		func(db *sqlite3.Conn, _, _, _ string, arg ...string) (*closure, error) {
+			var (
+				table  string
+				column string
+				parent string
+
+				done = util.Set[string]{}
+			)
+
+			for _, arg := range arg {
+				key, val := vtabutil.NamedArg(arg)
+				if done.Contains(key) {
+					return nil, fmt.Errorf("transitive_closure: more than one %q parameter", key)
+				}
+				switch key {
+				case "tablename":
+					table = vtabutil.Unquote(val)
+				case "idcolumn":
+					column = vtabutil.Unquote(val)
+				case "parentcolumn":
+					parent = vtabutil.Unquote(val)
+				default:
+					return nil, fmt.Errorf("transitive_closure: unknown %q parameter", key)
+				}
+				done.Add(key)
+			}
+
+			err := db.DeclareVTab(`CREATE TABLE x(id,depth,root HIDDEN,tablename HIDDEN,idcolumn HIDDEN,parentcolumn HIDDEN)`)
+			if err != nil {
+				return nil, err
+			}
+			return &closure{
+				db:     db,
+				table:  table,
+				column: column,
+				parent: parent,
+			}, nil
+		})
+}
+
+type closure struct {
+	db     *sqlite3.Conn
+	table  string
+	column string
+	parent string
+}
+
+func (c *closure) Destroy() error { return nil }
+
+func (c *closure) BestIndex(idx *sqlite3.IndexInfo) error {
+	plan := 0
+	posi := 1
+	cost := 1e7
+
+	for i, cst := range idx.Constraint {
+		if !cst.Usable {
+			continue
+		}
+		if plan&1 == 0 && cst.Column == _COL_ROOT {
+			switch cst.Op {
+			case sqlite3.INDEX_CONSTRAINT_EQ:
+				plan |= 1
+				cost /= 100
+				idx.ConstraintUsage[i] = sqlite3.IndexConstraintUsage{
+					ArgvIndex: 1,
+					Omit:      true,
+				}
+			}
+			continue
+		}
+		if plan&0xf0 == 0 && cst.Column == _COL_DEPTH {
+			switch cst.Op {
+			case sqlite3.INDEX_CONSTRAINT_LT, sqlite3.INDEX_CONSTRAINT_LE, sqlite3.INDEX_CONSTRAINT_EQ:
+				plan |= posi << 4
+				cost /= 5
+				posi += 1
+				idx.ConstraintUsage[i].ArgvIndex = posi
+				if cst.Op == sqlite3.INDEX_CONSTRAINT_LT {
+					plan |= 2
+				}
+			}
+			continue
+		}
+		if plan&0xf00 == 0 && cst.Column == _COL_TABLENAME {
+			switch cst.Op {
+			case sqlite3.INDEX_CONSTRAINT_EQ:
+				plan |= posi << 8
+				cost /= 5
+				posi += 1
+				idx.ConstraintUsage[i] = sqlite3.IndexConstraintUsage{
+					ArgvIndex: posi,
+					Omit:      true,
+				}
+			}
+			continue
+		}
+		if plan&0xf000 == 0 && cst.Column == _COL_IDCOLUMN {
+			switch cst.Op {
+			case sqlite3.INDEX_CONSTRAINT_EQ:
+				plan |= posi << 12
+				posi += 1
+				idx.ConstraintUsage[i] = sqlite3.IndexConstraintUsage{
+					ArgvIndex: posi,
+					Omit:      true,
+				}
+			}
+			continue
+		}
+		if plan&0xf0000 == 0 && cst.Column == _COL_PARENTCOLUMN {
+			switch cst.Op {
+			case sqlite3.INDEX_CONSTRAINT_EQ:
+				plan |= posi << 16
+				posi += 1
+				idx.ConstraintUsage[i] = sqlite3.IndexConstraintUsage{
+					ArgvIndex: posi,
+					Omit:      true,
+				}
+			}
+			continue
+		}
+	}
+
+	if plan&1 == 0 ||
+		c.table == "" && plan&0xf00 == 0 ||
+		c.column == "" && plan&0xf000 == 0 ||
+		c.parent == "" && plan&0xf0000 == 0 {
+		return sqlite3.CONSTRAINT
+	}
+
+	idx.EstimatedCost = cost
+	idx.IdxNum = plan
+	return nil
+}
+
+func (c *closure) Open() (sqlite3.VTabCursor, error) {
+	return &cursor{closure: c}, nil
+}
+
+type cursor struct {
+	*closure
+	nodes []node
+}
+
+type node struct {
+	id    int64
+	depth int
+}
+
+func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
+	root := arg[0].Int64()
+	maxDepth := math.MaxInt
+	if idxNum&0xf0 != 0 {
+		maxDepth = arg[(idxNum>>4)&0xf].Int()
+		if idxNum&2 != 0 {
+			maxDepth -= 1
+		}
+	}
+	table := c.table
+	if idxNum&0xf00 != 0 {
+		table = arg[(idxNum>>8)&0xf].Text()
+	}
+	column := c.column
+	if idxNum&0xf000 != 0 {
+		column = arg[(idxNum>>12)&0xf].Text()
+	}
+	parent := c.parent
+	if idxNum&0xf0000 != 0 {
+		parent = arg[(idxNum>>16)&0xf].Text()
+	}
+
+	sql := fmt.Sprintf(
+		`SELECT %[1]s.%[2]s FROM %[1]s WHERE %[1]s.%[3]s=?`,
+		sqlite3.QuoteIdentifier(table),
+		sqlite3.QuoteIdentifier(column),
+		sqlite3.QuoteIdentifier(parent),
+	)
+	stmt, _, err := c.db.Prepare(sql)
+	if err != nil {
+		return err
+	}
+	defer stmt.Close()
+
+	c.nodes = []node{{root, 0}}
+	set := util.Set[int64]{}
+	set.Add(root)
+	for i := 0; i < len(c.nodes); i++ {
+		curr := c.nodes[i]
+		if curr.depth >= maxDepth {
+			continue
+		}
+		stmt.BindInt64(1, curr.id)
+		for stmt.Step() {
+			if stmt.ColumnType(0) == sqlite3.INTEGER {
+				next := stmt.ColumnInt64(0)
+				if !set.Contains(next) {
+					set.Add(next)
+					c.nodes = append(c.nodes, node{next, curr.depth + 1})
+				}
+			}
+		}
+		stmt.Reset()
+	}
+	return nil
+}
+
+func (c *cursor) Column(ctx sqlite3.Context, n int) error {
+	switch n {
+	case _COL_ID:
+		ctx.ResultInt64(c.nodes[0].id)
+	case _COL_DEPTH:
+		ctx.ResultInt(c.nodes[0].depth)
+	case _COL_TABLENAME:
+		ctx.ResultText(c.table)
+	case _COL_IDCOLUMN:
+		ctx.ResultText(c.column)
+	case _COL_PARENTCOLUMN:
+		ctx.ResultText(c.parent)
+	}
+	return nil
+}
+
+func (c *cursor) Next() error {
+	c.nodes = c.nodes[1:]
+	return nil
+}
+
+func (c *cursor) EOF() bool {
+	return len(c.nodes) == 0
+}
+
+func (c *cursor) RowID() (int64, error) {
+	return c.nodes[0].id, nil
+}

ext/closure/closure_test.go

@@ -0,0 +1,184 @@
+package closure_test
+
+import (
+	_ "embed"
+	"fmt"
+	"log"
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+	_ "github.com/ncruces/go-sqlite3/embed"
+	"github.com/ncruces/go-sqlite3/ext/closure"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+)
+
+func TestMain(m *testing.M) {
+	sqlite3.AutoExtension(closure.Register)
+	m.Run()
+}
+
+func Example() {
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	closure.Register(db)
+
+	err = db.Exec(`
+		CREATE TABLE employees (
+			id INTEGER PRIMARY KEY,
+			parent_id INTEGER,
+			name TEXT
+		);
+		CREATE INDEX employees_parent_idx ON employees(parent_id);
+		INSERT INTO employees (id, parent_id, name) VALUES
+			(11, NULL, 'Diane'),
+			(12, 11, 'Bob'),
+			(21, 11, 'Emma'),
+			(22, 21, 'Grace'),
+			(23, 21, 'Henry'),
+			(24, 21, 'Irene'),
+			(25, 21, 'Frank'),
+			(31, 11, 'Cindy'),
+			(32, 31, 'Dave'),
+			(33, 31, 'Alice');
+		CREATE VIRTUAL TABLE hierarchy USING transitive_closure(
+			tablename = "employees",
+			idcolumn = "id",
+			parentcolumn = "parent_id"
+		);
+	`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`
+		SELECT employees.id, name FROM employees, hierarchy
+		WHERE employees.id = hierarchy.id AND hierarchy.root = 31
+	`)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer stmt.Close()
+
+	for stmt.Step() {
+		fmt.Println(stmt.ColumnInt(0), stmt.ColumnText(1))
+	}
+	if err := stmt.Err(); err != nil {
+		log.Fatal(err)
+	}
+
+	err = stmt.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = db.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+	// Output:
+	// 31 Cindy
+	// 32 Dave
+	// 33 Alice
+}
+
+func TestRegister(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Exec(`
+		CREATE TABLE employees (
+			id INTEGER PRIMARY KEY,
+			parent_id INTEGER,
+			name TEXT
+		);
+		CREATE INDEX employees_parent_idx ON employees(parent_id);
+		INSERT INTO employees (id, parent_id, name) VALUES
+			(11, NULL, 'Diane'),
+			(12, 11, 'Bob'),
+			(21, 11, 'Emma'),
+			(22, 21, 'Grace'),
+			(23, 21, 'Henry'),
+			(24, 21, 'Irene'),
+			(25, 21, 'Frank'),
+			(31, 11, 'Cindy'),
+			(32, 31, 'Dave'),
+			(33, 31, 'Alice');
+		CREATE VIRTUAL TABLE temp.closure USING transitive_closure;
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`
+		SELECT employees.id, name FROM employees, closure
+		 WHERE employees.id = closure.id
+		   AND closure.root = 31
+		   AND closure.depth < 1
+		   AND closure.tablename='employees'
+		   AND closure.idcolumn='id'
+		   AND closure.parentcolumn='parent_id'
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer stmt.Close()
+
+	if !stmt.Step() {
+		t.Error("want row")
+	}
+	if stmt.Step() {
+		t.Error("don't want row")
+	}
+	if err := stmt.Err(); err != nil {
+		t.Fatal(err)
+	}
+
+	err = stmt.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func Test_errors(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Exec(`CREATE VIRTUAL TABLE hierarchy USING transitive_closure(table='employees')`)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE hierarchy USING transitive_closure(tablename='employees', tablename="employees")`)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	err = db.Exec("CREATE VIRTUAL TABLE hierarchy USING transitive_closure(tablename=`employees`)")
+	if err != nil {
+		t.Error(err)
+	}
+
+	err = db.Exec(`SELECT * FROM hierarchy`)
+	if err == nil {
+		t.Error("want error")
+	}
+}

ext/csv/csv.go

@@ -30,7 +30,7 @@ func Register(db *sqlite3.Conn) error {
 // RegisterFS registers the CSV virtual table.
 // If a filename is specified, fsys is used to open the file.
 func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
-	declare := func(db *sqlite3.Conn, _, _, _ string, arg ...string) (_ *table, err error) {
+	declare := func(db *sqlite3.Conn, _, _, _ string, arg ...string) (res *table, err error) {
 		var (
 			filename string
 			data     string
@@ -40,12 +40,12 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
 			comma    rune = ','
 			comment  rune
 
-			done = map[string]struct{}{}
+			done = util.Set[string]{}
 		)
 
 		for _, arg := range arg {
 			key, val := vtabutil.NamedArg(arg)
-			if _, ok := done[key]; ok {
+			if done.Contains(key) {
 				return nil, fmt.Errorf("csv: more than one %q parameter", key)
 			}
 			switch key {
@@ -69,14 +69,14 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
 			if err != nil {
 				return nil, err
 			}
-			done[key] = struct{}{}
+			done.Add(key)
 		}
 
 		if (filename == "") == (data == "") {
 			return nil, util.ErrorString(`csv: must specify either "filename" or "data" but not both`)
 		}
 
-		table := &table{
+		t := &table{
 			fsys:    fsys,
 			name:    filename,
 			data:    data,
@@ -88,7 +88,7 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
 		if schema == "" {
 			var row []string
 			if header || columns < 0 {
-				csv, c, err := table.newReader()
+				csv, c, err := t.newReader()
 				defer c.Close()
 				if err != nil {
 					return nil, err
@@ -100,22 +100,20 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
 			}
 			schema = getSchema(header, columns, row)
 		} else {
-			defer func() {
-				if err == nil {
-					table.typs, err = getColumnAffinities(schema)
-				}
-			}()
+			t.typs, err = getColumnAffinities(schema)
+			if err != nil {
+				return nil, err
+			}
 		}
 
 		err = db.DeclareVTab(schema)
+		if err == nil {
+			err = db.VTabConfig(sqlite3.VTAB_DIRECTONLY)
+		}
 		if err != nil {
 			return nil, err
 		}
-		err = db.VTabConfig(sqlite3.VTAB_DIRECTONLY)
-		if err != nil {
-			return nil, err
-		}
-		return table, nil
+		return t, nil
 	}
 
 	return sqlite3.CreateModule(db, "csv", declare, declare)

ext/csv/csv_test.go

@@ -54,8 +54,9 @@ func Example() {
 	// On Twosday, 1€ = $1.1342
 }
 
-func init() {
+func TestMain(m *testing.M) {
 	sqlite3.AutoExtension(csv.Register)
+	m.Run()
 }
 
 func TestRegister(t *testing.T) {

ext/csv/types.go

@@ -22,8 +22,9 @@ func getColumnAffinities(schema string) ([]affinity, error) {
 		return nil, err
 	}
 
-	types := make([]affinity, len(tab.Columns))
-	for i, col := range tab.Columns {
+	columns := tab.Columns
+	types := make([]affinity, len(columns))
+	for i, col := range columns {
 		types[i] = getAffinity(col.Type)
 	}
 	return types, nil

ext/fileio/coro.go

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

ext/fileio/fileio.go

@@ -31,7 +31,9 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
 		db.CreateFunction("lsmode", 1, sqlite3.DETERMINISTIC, lsmode),
 		sqlite3.CreateModule(db, "fsdir", nil, func(db *sqlite3.Conn, _, _, _ string, _ ...string) (fsdir, error) {
 			err := db.DeclareVTab(`CREATE TABLE x(name,mode,mtime TIMESTAMP,data,path HIDDEN,dir HIDDEN)`)
-			db.VTabConfig(sqlite3.VTAB_DIRECTONLY)
+			if err == nil {
+				err = db.VTabConfig(sqlite3.VTAB_DIRECTONLY)
+			}
 			return fsdir{fsys}, err
 		}))
 }

ext/fileio/fsdir.go

@@ -10,13 +10,22 @@ import (
 	"github.com/ncruces/go-sqlite3"
 )
 
+const (
+	_COL_NAME = 0
+	_COL_MODE = 1
+	_COL_TIME = 2
+	_COL_DATA = 3
+	_COL_ROOT = 4
+	_COL_BASE = 5
+)
+
 type fsdir struct{ fsys fs.FS }
 
 func (d fsdir) BestIndex(idx *sqlite3.IndexInfo) error {
 	var root, base bool
 	for i, cst := range idx.Constraint {
 		switch cst.Column {
-		case 4: // root
+		case _COL_ROOT:
 			if !cst.Usable || cst.Op != sqlite3.INDEX_CONSTRAINT_EQ {
 				return sqlite3.CONSTRAINT
 			}
@@ -25,7 +34,7 @@ func (d fsdir) BestIndex(idx *sqlite3.IndexInfo) error {
 				ArgvIndex: 1,
 			}
 			root = true
-		case 5: // base
+		case _COL_BASE:
 			if !cst.Usable || cst.Op != sqlite3.INDEX_CONSTRAINT_EQ {
 				return sqlite3.CONSTRAINT
 			}
@@ -116,25 +125,25 @@ func (c *cursor) RowID() (int64, error) {
 
 func (c *cursor) Column(ctx sqlite3.Context, n int) error {
 	switch n {
-	case 0: // name
+	case _COL_NAME:
 		name := strings.TrimPrefix(c.curr.path, c.base)
 		ctx.ResultText(name)
 
-	case 1: // mode
+	case _COL_MODE:
 		i, err := c.curr.Info()
 		if err != nil {
 			return err
 		}
 		ctx.ResultInt64(int64(i.Mode()))
 
-	case 2: // mtime
+	case _COL_TIME:
 		i, err := c.curr.Info()
 		if err != nil {
 			return err
 		}
 		ctx.ResultTime(i.ModTime(), sqlite3.TimeFormatUnixFrac)
 
-	case 3: // data
+	case _COL_DATA:
 		switch typ := c.curr.Type(); {
 		case typ.IsRegular():
 			var data []byte

ext/fileio/fsdir_coro.go

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

ext/fileio/fsdir_iter.go

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

ext/hash/hash.go

@@ -29,7 +29,7 @@ import (
 
 // Register registers cryptographic hash functions for a database connection.
 func Register(db *sqlite3.Conn) error {
-	flags := sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
+	const flags = sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
 
 	var errs util.ErrorJoiner
 	if crypto.MD4.Available() {

ext/lines/lines.go

@@ -39,13 +39,17 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
 		sqlite3.CreateModule(db, "lines", nil,
 			func(db *sqlite3.Conn, _, _, _ string, _ ...string) (lines, error) {
 				err := db.DeclareVTab(`CREATE TABLE x(line TEXT, data HIDDEN)`)
-				db.VTabConfig(sqlite3.VTAB_INNOCUOUS)
+				if err == nil {
+					err = db.VTabConfig(sqlite3.VTAB_INNOCUOUS)
+				}
 				return lines{}, err
 			}),
 		sqlite3.CreateModule(db, "lines_read", nil,
 			func(db *sqlite3.Conn, _, _, _ string, _ ...string) (lines, error) {
 				err := db.DeclareVTab(`CREATE TABLE x(line TEXT, data HIDDEN)`)
-				db.VTabConfig(sqlite3.VTAB_DIRECTONLY)
+				if err == nil {
+					err = db.VTabConfig(sqlite3.VTAB_DIRECTONLY)
+				}
 				return lines{fsys}, err
 			}))
 }

ext/pivot/pivot.go

@@ -25,15 +25,15 @@ type table struct {
 	cols []*sqlite3.Value
 }
 
-func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (_ *table, err error) {
+func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (res *table, err error) {
 	if len(arg) != 3 {
 		return nil, fmt.Errorf("pivot: wrong number of arguments")
 	}
 
-	table := &table{db: db}
+	t := &table{db: db}
 	defer func() {
-		if err != nil {
-			table.Close()
+		if res == nil {
+			t.Close()
 		}
 	}()
 
@@ -42,17 +42,17 @@ func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (_ *table, err err
 	create.WriteString("CREATE TABLE x(")
 
 	// Row key query.
-	table.scan = "SELECT * FROM\n" + arg[0]
-	stmt, _, err := db.Prepare(table.scan)
+	t.scan = "SELECT * FROM\n" + arg[0]
+	stmt, _, err := db.Prepare(t.scan)
 	if err != nil {
 		return nil, err
 	}
 	defer stmt.Close()
 
-	table.keys = make([]string, stmt.ColumnCount())
-	for i := range table.keys {
+	t.keys = make([]string, stmt.ColumnCount())
+	for i := range t.keys {
 		name := sqlite3.QuoteIdentifier(stmt.ColumnName(i))
-		table.keys[i] = name
+		t.keys[i] = name
 		create.WriteString(sep)
 		create.WriteString(name)
 		sep = ","
@@ -70,15 +70,15 @@ func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (_ *table, err err
 	}
 	for stmt.Step() {
 		name := sqlite3.QuoteIdentifier(stmt.ColumnText(1))
-		table.cols = append(table.cols, stmt.ColumnValue(0).Dup())
+		t.cols = append(t.cols, stmt.ColumnValue(0).Dup())
 		create.WriteString(",")
 		create.WriteString(name)
 	}
 	stmt.Close()
 
 	// Pivot cell query.
-	table.cell = "SELECT * FROM\n" + arg[2]
-	stmt, _, err = db.Prepare(table.cell)
+	t.cell = "SELECT * FROM\n" + arg[2]
+	stmt, _, err = db.Prepare(t.cell)
 	if err != nil {
 		return nil, err
 	}
@@ -86,8 +86,8 @@ func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (_ *table, err err
 	if stmt.ColumnCount() != 1 {
 		return nil, util.ErrorString("pivot: cell query expects 1 result columns")
 	}
-	if stmt.BindCount() != len(table.keys)+1 {
-		return nil, fmt.Errorf("pivot: cell query expects %d bound parameters", len(table.keys)+1)
+	if stmt.BindCount() != len(t.keys)+1 {
+		return nil, fmt.Errorf("pivot: cell query expects %d bound parameters", len(t.keys)+1)
 	}
 
 	create.WriteByte(')')
@@ -95,12 +95,12 @@ func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (_ *table, err err
 	if err != nil {
 		return nil, err
 	}
-	return table, nil
+	return t, nil
 }
 
 func (t *table) Close() error {
-	for i := range t.cols {
-		t.cols[i].Close()
+	for _, c := range t.cols {
+		c.Close()
 	}
 	return nil
 }

ext/pivot/pivot_test.go

@@ -83,8 +83,9 @@ func Example() {
 	// gamma   80      75      78      80
 }
 
-func init() {
+func TestMain(m *testing.M) {
 	sqlite3.AutoExtension(pivot.Register)
+	m.Run()
 }
 
 func TestRegister(t *testing.T) {

ext/regexp/regexp.go

@@ -20,7 +20,7 @@ import (
 
 // Register registers Unicode aware functions for a database connection.
 func Register(db *sqlite3.Conn) error {
-	flags := sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
+	const flags = sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
 	return errors.Join(
 		db.CreateFunction("regexp", 2, flags, regex),
 		db.CreateFunction("regexp_like", 2, flags, regexLike),

ext/statement/stmt.go

@@ -34,7 +34,7 @@ func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (*table, error) {
 
 	sql := "SELECT * FROM\n" + arg[0]
 
-	stmt, _, err := db.Prepare(sql)
+	stmt, _, err := db.PrepareFlags(sql, sqlite3.PREPARE_PERSISTENT)
 	if err != nil {
 		return nil, err
 	}

ext/statement/stmt_test.go

@@ -48,8 +48,9 @@ func Example() {
 	// Twosday was 2022-2-22
 }
 
-func init() {
+func TestMain(m *testing.M) {
 	sqlite3.AutoExtension(statement.Register)
+	m.Run()
 }
 
 func TestRegister(t *testing.T) {

ext/stats/percentile.go

@@ -28,11 +28,13 @@ type percentile struct {
 }
 
 func (q *percentile) Step(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	if a := arg[0]; a.NumericType() != sqlite3.NULL {
-		q.nums = append(q.nums, a.Float())
+	a := arg[0]
+	f := a.Float()
+	if f != 0.0 || a.NumericType() != sqlite3.NULL {
+		q.nums = append(q.nums, f)
 	}
-	if q.kind != median {
-		q.arg1 = arg[1].Blob(q.arg1[:0])
+	if q.kind != median && q.arg1 == nil {
+		q.arg1 = append(q.arg1, arg[1].RawText()...)
 	}
 }
 
@@ -79,7 +81,7 @@ func getPercentile(nums []float64, pos float64, disc bool) (float64, error) {
 	}
 
 	m1 := slices.Min(nums[int(i)+1:])
-	return math.FMA(f, m1, -math.FMA(f, m0, -m0)), nil
+	return math.FMA(f, m1, math.FMA(-f, m0, m0)), nil
 }
 
 func getPercentiles(nums []float64, pos []float64, disc bool) error {

ext/stats/stats.go

@@ -52,7 +52,7 @@ import (
 
 // Register registers statistics functions.
 func Register(db *sqlite3.Conn) error {
-	flags := sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
+	const flags = sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
 	return errors.Join(
 		db.CreateWindowFunction("var_pop", 1, flags, newVariance(var_pop)),
 		db.CreateWindowFunction("var_samp", 1, flags, newVariance(var_samp)),
@@ -121,14 +121,18 @@ func (fn *variance) Value(ctx sqlite3.Context) {
 }
 
 func (fn *variance) Step(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	if a := arg[0]; a.NumericType() != sqlite3.NULL {
-		fn.enqueue(a.Float())
+	a := arg[0]
+	f := a.Float()
+	if f != 0.0 || a.NumericType() != sqlite3.NULL {
+		fn.enqueue(f)
 	}
 }
 
 func (fn *variance) Inverse(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	if a := arg[0]; a.NumericType() != sqlite3.NULL {
-		fn.dequeue(a.Float())
+	a := arg[0]
+	f := a.Float()
+	if f != 0.0 || a.NumericType() != sqlite3.NULL {
+		fn.dequeue(f)
 	}
 }
 
@@ -177,15 +181,23 @@ func (fn *covariance) Value(ctx sqlite3.Context) {
 }
 
 func (fn *covariance) Step(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	a, b := arg[0], arg[1]
-	if a.NumericType() != sqlite3.NULL && b.NumericType() != sqlite3.NULL {
-		fn.enqueue(a.Float(), b.Float())
+	b, a := arg[1], arg[0] // avoid a bounds check
+	fa := a.Float()
+	fb := b.Float()
+	if true &&
+		(fa != 0.0 || a.NumericType() != sqlite3.NULL) &&
+		(fb != 0.0 || b.NumericType() != sqlite3.NULL) {
+		fn.enqueue(fa, fb)
 	}
 }
 
 func (fn *covariance) Inverse(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	a, b := arg[0], arg[1]
-	if a.NumericType() != sqlite3.NULL && b.NumericType() != sqlite3.NULL {
-		fn.dequeue(a.Float(), b.Float())
+	b, a := arg[1], arg[0] // avoid a bounds check
+	fa := a.Float()
+	fb := b.Float()
+	if true &&
+		(fa != 0.0 || a.NumericType() != sqlite3.NULL) &&
+		(fb != 0.0 || b.NumericType() != sqlite3.NULL) {
+		fn.dequeue(fa, fb)
 	}
 }

ext/stats/stats_test.go

@@ -10,8 +10,9 @@ import (
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
-func init() {
+func TestMain(m *testing.M) {
 	sqlite3.AutoExtension(stats.Register)
+	m.Run()
 }
 
 func TestRegister_variance(t *testing.T) {

ext/unicode/unicode.go

@@ -5,6 +5,10 @@
 //   - LIKE and REGEXP operators,
 //   - collation sequences.
 //
+// It also provides, from PostgreSQL:
+//   - unaccent(),
+//   - initcap().
+//
 // 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;
@@ -21,6 +25,7 @@ import (
 	"errors"
 	"regexp"
 	"strings"
+	"unicode"
 	"unicode/utf8"
 
 	"github.com/ncruces/go-sqlite3"
@@ -28,19 +33,35 @@ import (
 	"golang.org/x/text/cases"
 	"golang.org/x/text/collate"
 	"golang.org/x/text/language"
+	"golang.org/x/text/runes"
+	"golang.org/x/text/transform"
+	"golang.org/x/text/unicode/norm"
 )
 
+// Set RegisterLike to false to not register a Unicode aware LIKE operator.
+// Overriding the built-in LIKE operator disables the [LIKE optimization].
+//
+// [LIKE optimization]: https://sqlite.org/optoverview.html#the_like_optimization
+var RegisterLike = true
+
 // Register registers Unicode aware functions for a database connection.
 func Register(db *sqlite3.Conn) error {
-	flags := sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
-	return errors.Join(
-		db.CreateFunction("like", 2, flags, like),
-		db.CreateFunction("like", 3, flags, like),
+	const flags = sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
+	var errs util.ErrorJoiner
+	if RegisterLike {
+		errs.Join(
+			db.CreateFunction("like", 2, flags, like),
+			db.CreateFunction("like", 3, flags, like))
+	}
+	errs.Join(
 		db.CreateFunction("upper", 1, flags, upper),
 		db.CreateFunction("upper", 2, flags, upper),
 		db.CreateFunction("lower", 1, flags, lower),
 		db.CreateFunction("lower", 2, flags, lower),
 		db.CreateFunction("regexp", 2, flags, regex),
+		db.CreateFunction("initcap", 1, flags, initcap),
+		db.CreateFunction("initcap", 2, flags, initcap),
+		db.CreateFunction("unaccent", 1, flags, unaccent),
 		db.CreateFunction("icu_load_collation", 2, sqlite3.DIRECTONLY,
 			func(ctx sqlite3.Context, arg ...sqlite3.Value) {
 				name := arg[1].Text()
@@ -48,12 +69,13 @@ func Register(db *sqlite3.Conn) error {
 					return
 				}
 
-				err := RegisterCollation(db, arg[0].Text(), name)
+				err := RegisterCollation(ctx.Conn(), arg[0].Text(), name)
 				if err != nil {
 					ctx.ResultError(err)
 					return // notest
 				}
 			}))
+	return errors.Join(errs...)
 }
 
 // RegisterCollation registers a Unicode collation sequence for a database connection.
@@ -65,6 +87,15 @@ func RegisterCollation(db *sqlite3.Conn, locale, name string) error {
 	return db.CreateCollation(name, collate.New(tag).Compare)
 }
 
+// RegisterCollationsNeeded registers Unicode collation sequences on demand for a database connection.
+func RegisterCollationsNeeded(db *sqlite3.Conn) error {
+	return db.CollationNeeded(func(db *sqlite3.Conn, name string) {
+		if tag, err := language.Parse(name); err == nil {
+			db.CreateCollation(name, collate.New(tag).Compare)
+		}
+	})
+}
+
 func upper(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	if len(arg) == 1 {
 		ctx.ResultRawText(bytes.ToUpper(arg[0].RawText()))
@@ -103,6 +134,35 @@ func lower(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	ctx.ResultRawText(cs.Bytes(arg[0].RawText()))
 }
 
+func initcap(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	if len(arg) == 1 {
+		ctx.ResultRawText(bytes.Title(arg[0].RawText()))
+		return
+	}
+	cs, ok := ctx.GetAuxData(1).(cases.Caser)
+	if !ok {
+		t, err := language.Parse(arg[1].Text())
+		if err != nil {
+			ctx.ResultError(err)
+			return // notest
+		}
+		c := cases.Title(t)
+		ctx.SetAuxData(1, c)
+		cs = c
+	}
+	ctx.ResultRawText(cs.Bytes(arg[0].RawText()))
+}
+
+func unaccent(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	unaccent := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
+	res, _, err := transform.Bytes(unaccent, arg[0].RawText())
+	if err != nil {
+		ctx.ResultError(err) // notest
+	} else {
+		ctx.ResultRawText(res)
+	}
+}
+
 func regex(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	re, ok := ctx.GetAuxData(0).(*regexp.Regexp)
 	if !ok {

ext/unicode/unicode_test.go

@@ -47,6 +47,9 @@ func TestRegister(t *testing.T) {
 		{`upper('istanbul', 'tr-TR')`, "İSTANBUL"},
 		{`lower('Dünyanın İlk Borsası', 'tr-TR')`, "dünyanın ilk borsası"},
 		{`upper('Dünyanın İlk Borsası', 'tr-TR')`, "DÜNYANIN İLK BORSASI"},
+		{`initcap('Kad je hladno Marko nosi džemper')`, "Kad Je Hladno Marko Nosi Džemper"},
+		{`initcap('Kad je hladno Marko nosi džemper', 'hr-HR')`, "Kad Je Hladno Marko Nosi Džemper"},
+		{`unaccent('Hôtel')`, "Hotel"},
 		{`'Hello' REGEXP 'ell'`, "1"},
 		{`'Hello' REGEXP 'el.'`, "1"},
 		{`'Hello' LIKE 'hel_'`, "0"},
@@ -92,7 +95,7 @@ func TestRegister_collation(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	err = db.Exec(`SELECT icu_load_collation('fr_FR', 'french')`)
+	err = db.Exec(`SELECT icu_load_collation('fr-FR', 'french')`)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -127,6 +130,57 @@ func TestRegister_collation(t *testing.T) {
 	}
 }
 
+func TestRegisterCollationsNeeded(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	RegisterCollationsNeeded(db)
+
+	err = db.Exec(`CREATE TABLE words (word VARCHAR(10))`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`INSERT INTO words (word) VALUES ('côte'), ('cote'), ('coter'), ('coté'), ('cotée'), ('côté')`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT word FROM words ORDER BY word COLLATE fr_FR`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer stmt.Close()
+
+	got, want := []string{}, []string{"cote", "coté", "côte", "côté", "cotée", "coter"}
+
+	for stmt.Step() {
+		got = append(got, stmt.ColumnText(0))
+	}
+	if err := stmt.Err(); err != nil {
+		t.Fatal(err)
+	}
+
+	if !reflect.DeepEqual(got, want) {
+		t.Error("not equal")
+	}
+
+	err = stmt.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
 func TestRegister_error(t *testing.T) {
 	t.Parallel()
 

ext/uuid/uuid.go

@@ -27,7 +27,7 @@ import (
 //
 // Converts a UUID into a 16-byte blob.
 func Register(db *sqlite3.Conn) error {
-	flags := sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
+	const flags = sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
 	return errors.Join(
 		db.CreateFunction("uuid", 0, sqlite3.INNOCUOUS, generate),
 		db.CreateFunction("uuid", 1, sqlite3.INNOCUOUS, generate),
@@ -66,23 +66,23 @@ func generate(ctx sqlite3.Context, arg ...sqlite3.Value) {
 			domain = uuid.Domain(arg[1].Int64())
 			if domain == 0 {
 				if txt := arg[1].RawText(); len(txt) > 0 {
-					switch txt[0] | 0x20 {
+					switch txt[0] | 0x20 { // to lower
 					case 'g': // group
-						domain = 1
+						domain = uuid.Group
 					case 'o': // org
-						domain = 2
+						domain = uuid.Org
 					}
 				}
 			}
 		}
-		if len(arg) > 2 {
-			id := uint32(arg[2].Int64())
-			u, err = uuid.NewDCESecurity(domain, id)
-		} else if domain == uuid.Person {
+		switch {
+		case len(arg) > 2:
+			u, err = uuid.NewDCESecurity(domain, uint32(arg[2].Int64()))
+		case domain == uuid.Person:
 			u, err = uuid.NewDCEPerson()
-		} else if domain == uuid.Group {
+		case domain == uuid.Group:
 			u, err = uuid.NewDCEGroup()
-		} else {
+		default:
 			err = util.ErrorString("missing id")
 		}
 

ext/zorder/zorder.go

@@ -12,7 +12,7 @@ import (
 
 // Register registers the zorder and unzorder SQL functions.
 func Register(db *sqlite3.Conn) error {
-	flags := sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
+	const flags = sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
 	return errors.Join(
 		db.CreateFunction("zorder", -1, flags, zorder),
 		db.CreateFunction("unzorder", 3, flags, unzorder))
@@ -47,9 +47,9 @@ func zorder(ctx sqlite3.Context, arg ...sqlite3.Value) {
 }
 
 func unzorder(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	z := arg[0].Int64()
-	n := arg[1].Int64()
 	i := arg[2].Int64()
+	n := arg[1].Int64()
+	z := arg[0].Int64()
 
 	var k int
 	var x int64

func.go

@@ -33,16 +33,23 @@ func (c *Conn) CollationNeeded(cb func(db *Conn, name string)) error {
 // one or more unknown collating sequences.
 func (c Conn) AnyCollationNeeded() error {
 	r := c.call("sqlite3_anycollseq_init", uint64(c.handle), 0, 0)
-	return c.error(r)
+	if err := c.error(r); err != nil {
+		return err
+	}
+	c.collation = nil
+	return nil
 }
 
 // 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 {
+	var funcPtr uint32
 	defer c.arena.mark()()
 	namePtr := c.arena.string(name)
-	funcPtr := util.AddHandle(c.ctx, fn)
+	if fn != nil {
+		funcPtr = util.AddHandle(c.ctx, fn)
+	}
 	r := c.call("sqlite3_create_collation_go",
 		uint64(c.handle), uint64(namePtr), uint64(funcPtr))
 	return c.error(r)
@@ -52,9 +59,12 @@ func (c *Conn) CreateCollation(name string, fn func(a, b []byte) int) error {
 //
 // https://sqlite.org/c3ref/create_function.html
 func (c *Conn) CreateFunction(name string, nArg int, flag FunctionFlag, fn ScalarFunction) error {
+	var funcPtr uint32
 	defer c.arena.mark()()
 	namePtr := c.arena.string(name)
-	funcPtr := util.AddHandle(c.ctx, fn)
+	if fn != nil {
+		funcPtr = util.AddHandle(c.ctx, fn)
+	}
 	r := c.call("sqlite3_create_function_go",
 		uint64(c.handle), uint64(namePtr), uint64(nArg),
 		uint64(flag), uint64(funcPtr))
@@ -71,10 +81,13 @@ type ScalarFunction func(ctx Context, arg ...Value)
 //
 // https://sqlite.org/c3ref/create_function.html
 func (c *Conn) CreateWindowFunction(name string, nArg int, flag FunctionFlag, fn func() AggregateFunction) error {
+	var funcPtr uint32
 	defer c.arena.mark()()
-	call := "sqlite3_create_aggregate_function_go"
 	namePtr := c.arena.string(name)
-	funcPtr := util.AddHandle(c.ctx, fn)
+	if fn != nil {
+		funcPtr = util.AddHandle(c.ctx, fn)
+	}
+	call := "sqlite3_create_aggregate_function_go"
 	if _, ok := fn().(WindowFunction); ok {
 		call = "sqlite3_create_window_function_go"
 	}
@@ -184,11 +197,12 @@ func callbackAggregate(db *Conn, pAgg, pApp uint32) (AggregateFunction, uint32)
 
 	// We need to create the aggregate.
 	fn := util.GetHandle(db.ctx, pApp).(func() AggregateFunction)()
-	handle := util.AddHandle(db.ctx, fn)
 	if pAgg != 0 {
+		handle := util.AddHandle(db.ctx, fn)
 		util.WriteUint32(db.mod, pAgg, handle)
+		return fn, handle
 	}
-	return fn, handle
+	return fn, 0
 }
 
 func callbackArgs(db *Conn, arg []Value, pArg uint32) {

func_win_test.go

@@ -78,7 +78,7 @@ func (f *countASCII) isASCII(arg sqlite3.Value) bool {
 	if arg.Type() != sqlite3.TEXT {
 		return false
 	}
-	for _, c := range arg.RawBlob() {
+	for _, c := range arg.RawText() {
 		if c > unicode.MaxASCII {
 			return false
 		}

go.mod

@@ -6,17 +6,16 @@ toolchain go1.23.0
 
 require (
 	github.com/dchest/siphash v1.2.3
+	github.com/google/uuid v1.6.0
 	github.com/ncruces/julianday v1.0.0
 	github.com/ncruces/sort v0.1.2
 	github.com/psanford/httpreadat v0.1.0
-	github.com/tetratelabs/wazero v1.8.0
-	golang.org/x/crypto v0.26.0
+	github.com/tetratelabs/wazero v1.8.1
+	golang.org/x/crypto v0.28.0
 	golang.org/x/sync v0.8.0
-	golang.org/x/sys v0.24.0
-	golang.org/x/text v0.17.0
+	golang.org/x/sys v0.26.0
+	golang.org/x/text v0.19.0
 	lukechampine.com/adiantum v1.1.1
 )
 
-require github.com/google/uuid v1.6.0
-
 retract v0.4.0 // tagged from the wrong branch

go.sum

@@ -8,15 +8,15 @@ github.com/ncruces/sort v0.1.2 h1:zKQ9CA4fpHPF6xsUhRTfi5EEryspuBpe/QA4VWQOV1U=
 github.com/ncruces/sort v0.1.2/go.mod h1:vEJUTBJtebIuCMmXD18GKo5GJGhsay+xZFOoBEIXFmE=
 github.com/psanford/httpreadat v0.1.0 h1:VleW1HS2zO7/4c7c7zNl33fO6oYACSagjJIyMIwZLUE=
 github.com/psanford/httpreadat v0.1.0/go.mod h1:Zg7P+TlBm3bYbyHTKv/EdtSJZn3qwbPwpfZ/I9GKCRE=
-github.com/tetratelabs/wazero v1.8.0 h1:iEKu0d4c2Pd+QSRieYbnQC9yiFlMS9D+Jr0LsRmcF4g=
-github.com/tetratelabs/wazero v1.8.0/go.mod h1:yAI0XTsMBhREkM/YDAK/zNou3GoiAce1P6+rp/wQhjs=
-golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw=
-golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54=
+github.com/tetratelabs/wazero v1.8.1 h1:NrcgVbWfkWvVc4UtT4LRLDf91PsOzDzefMdwhLfA550=
+github.com/tetratelabs/wazero v1.8.1/go.mod h1:yAI0XTsMBhREkM/YDAK/zNou3GoiAce1P6+rp/wQhjs=
+golang.org/x/crypto v0.28.0 h1:GBDwsMXVQi34v5CCYUm2jkJvu4cbtru2U4TN2PSyQnw=
+golang.org/x/crypto v0.28.0/go.mod h1:rmgy+3RHxRZMyY0jjAJShp2zgEdOqj2AO7U0pYmeQ7U=
 golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
 golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.24.0 h1:Twjiwq9dn6R1fQcyiK+wQyHWfaz/BJB+YIpzU/Cv3Xg=
-golang.org/x/sys v0.24.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc=
-golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
+golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
+golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
 lukechampine.com/adiantum v1.1.1 h1:4fp6gTxWCqpEbLy40ExiYDDED3oUNWx5cTqBCtPdZqA=
 lukechampine.com/adiantum v1.1.1/go.mod h1:LrAYVnTYLnUtE/yMp5bQr0HstAf060YUF8nM0B6+rUw=

go.work.sum

@@ -1,9 +1,13 @@
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
+golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
 golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
 golang.org/x/term v0.21.0/go.mod h1:ooXLefLobQVslOqselCNF4SxFAaoS6KujMbsGzSDmX0=
 golang.org/x/term v0.22.0/go.mod h1:F3qCibpT5AMpCRfhfT53vVJwhLtIVHhB9XDjfFvnMI4=
 golang.org/x/term v0.23.0/go.mod h1:DgV24QBUrK6jhZXl+20l6UWznPlwAHm1Q1mGHtydmSk=
+golang.org/x/term v0.24.0/go.mod h1:lOBK/LVxemqiMij05LGJ0tzNr8xlmwBRJ81PX6wVLH8=
+golang.org/x/term v0.25.0/go.mod h1:RPyXicDX+6vLxogjjRxjgD2TKtmAO6NZBsBRfrOLu7M=
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=

gormlite/error_translator_test.go

@@ -3,20 +3,18 @@ package gormlite
 import (
 	"testing"
 
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
 )
 
 func TestErrorTranslator(t *testing.T) {
-	// This is the DSN of the in-memory SQLite database for these tests.
-	const InMemoryDSN = "file:testdatabase?mode=memory&cache=shared"
-
 	// This is the example object for testing the unique constraint error
 	type Article struct {
 		ArticleNumber string `gorm:"unique"`
 	}
 
-	db, err := gorm.Open(Open(InMemoryDSN), &gorm.Config{
+	db, err := gorm.Open(Open(memdb.TestDB(t)), &gorm.Config{
 		Logger:         logger.Default.LogMode(logger.Silent),
 		TranslateError: true})
 

gormlite/go.mod

@@ -5,15 +5,15 @@ go 1.21
 toolchain go1.23.0
 
 require (
-	github.com/ncruces/go-sqlite3 v0.17.1
-	gorm.io/gorm v1.25.11
+	github.com/ncruces/go-sqlite3 v0.18.4
+	gorm.io/gorm v1.25.12
 )
 
 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.0 // indirect
-	golang.org/x/sys v0.24.0 // indirect
-	golang.org/x/text v0.17.0 // indirect
+	github.com/tetratelabs/wazero v1.8.1 // indirect
+	golang.org/x/sys v0.26.0 // indirect
+	golang.org/x/text v0.19.0 // indirect
 )

gormlite/go.sum

@@ -2,15 +2,15 @@ github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
 github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
-github.com/ncruces/go-sqlite3 v0.17.1 h1:VxTjDpCn87FaFlKMaAYC1jP7ND0d4UNj+6G4IQDHbgI=
-github.com/ncruces/go-sqlite3 v0.17.1/go.mod h1:FnCyui8SlDoL0mQZ5dTouNo7s7jXS0kJv9lBt1GlM9w=
+github.com/ncruces/go-sqlite3 v0.18.4 h1:Je8o3y33MDwPYY/Cacas8yCsuoUzpNY/AgoSlN2ekyE=
+github.com/ncruces/go-sqlite3 v0.18.4/go.mod h1:4HLag13gq1k10s4dfGBhMfRVsssJRT9/5hYqVM9RUYo=
 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.0 h1:iEKu0d4c2Pd+QSRieYbnQC9yiFlMS9D+Jr0LsRmcF4g=
-github.com/tetratelabs/wazero v1.8.0/go.mod h1:yAI0XTsMBhREkM/YDAK/zNou3GoiAce1P6+rp/wQhjs=
-golang.org/x/sys v0.24.0 h1:Twjiwq9dn6R1fQcyiK+wQyHWfaz/BJB+YIpzU/Cv3Xg=
-golang.org/x/sys v0.24.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc=
-golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
-gorm.io/gorm v1.25.11 h1:/Wfyg1B/je1hnDx3sMkX+gAlxrlZpn6X0BXRlwXlvHg=
-gorm.io/gorm v1.25.11/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ=
+github.com/tetratelabs/wazero v1.8.1 h1:NrcgVbWfkWvVc4UtT4LRLDf91PsOzDzefMdwhLfA550=
+github.com/tetratelabs/wazero v1.8.1/go.mod h1:yAI0XTsMBhREkM/YDAK/zNou3GoiAce1P6+rp/wQhjs=
+golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
+golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
+golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+gorm.io/gorm v1.25.12 h1:I0u8i2hWQItBq1WfE0o2+WuL9+8L21K9e2HHSTE/0f8=
+gorm.io/gorm v1.25.12/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ=

gormlite/test.sh

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

internal/alloc/alloc_slice.go

@@ -1,4 +1,4 @@
-//go:build !(darwin || linux) || !(amd64 || arm64 || riscv64) || sqlite3_noshm || sqlite3_nosys
+//go:build !(darwin || linux) || !(amd64 || arm64 || riscv64 || ppc64le) || sqlite3_noshm || sqlite3_nosys
 
 package alloc
 

internal/alloc/alloc_unix.go

@@ -39,7 +39,7 @@ type mmappedMemory struct {
 func (m *mmappedMemory) Reallocate(size uint64) []byte {
 	com := uint64(len(m.buf))
 	res := uint64(cap(m.buf))
-	if com < size && size < res {
+	if com < size && size <= res {
 		// Round up to the page size.
 		rnd := uint64(unix.Getpagesize() - 1)
 		new := (size + rnd) &^ rnd
@@ -47,7 +47,7 @@ func (m *mmappedMemory) Reallocate(size uint64) []byte {
 		// Commit additional memory up to new bytes.
 		err := unix.Mprotect(m.buf[com:new], unix.PROT_READ|unix.PROT_WRITE)
 		if err != nil {
-			panic(err)
+			return nil
 		}
 
 		// Update committed memory.

internal/alloc/alloc_windows.go

@@ -48,7 +48,7 @@ type virtualMemory struct {
 func (m *virtualMemory) Reallocate(size uint64) []byte {
 	com := uint64(len(m.buf))
 	res := uint64(cap(m.buf))
-	if com < size && size < res {
+	if com < size && size <= res {
 		// Round up to the page size.
 		rnd := uint64(windows.Getpagesize() - 1)
 		new := (size + rnd) &^ rnd
@@ -56,7 +56,7 @@ func (m *virtualMemory) Reallocate(size uint64) []byte {
 		// Commit additional memory up to new bytes.
 		_, err := windows.VirtualAlloc(m.addr, uintptr(new), windows.MEM_COMMIT, windows.PAGE_READWRITE)
 		if err != nil {
-			panic(err)
+			return nil
 		}
 
 		// Update committed memory.

internal/util/func.go

@@ -26,6 +26,7 @@ func ExportFuncVI[T0 i32](mod wazero.HostModuleBuilder, name string, fn func(con
 type funcVII[T0, T1 i32] func(context.Context, api.Module, T0, T1)
 
 func (fn funcVII[T0, T1]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	_ = stack[1] // prevent bounds check on every slice access
 	fn(ctx, mod, T0(stack[0]), T1(stack[1]))
 }
 
@@ -39,6 +40,7 @@ func ExportFuncVII[T0, T1 i32](mod wazero.HostModuleBuilder, name string, fn fun
 type funcVIII[T0, T1, T2 i32] func(context.Context, api.Module, T0, T1, T2)
 
 func (fn funcVIII[T0, T1, T2]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	_ = stack[2] // prevent bounds check on every slice access
 	fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]))
 }
 
@@ -52,6 +54,7 @@ func ExportFuncVIII[T0, T1, T2 i32](mod wazero.HostModuleBuilder, name string, f
 type funcVIIII[T0, T1, T2, T3 i32] func(context.Context, api.Module, T0, T1, T2, T3)
 
 func (fn funcVIIII[T0, T1, T2, T3]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	_ = stack[3] // prevent bounds check on every slice access
 	fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3]))
 }
 
@@ -65,6 +68,7 @@ func ExportFuncVIIII[T0, T1, T2, T3 i32](mod wazero.HostModuleBuilder, name stri
 type funcVIIIII[T0, T1, T2, T3, T4 i32] func(context.Context, api.Module, T0, T1, T2, T3, T4)
 
 func (fn funcVIIIII[T0, T1, T2, T3, T4]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	_ = stack[4] // prevent bounds check on every slice access
 	fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3]), T4(stack[4]))
 }
 
@@ -78,6 +82,7 @@ func ExportFuncVIIIII[T0, T1, T2, T3, T4 i32](mod wazero.HostModuleBuilder, name
 type funcVIIIIJ[T0, T1, T2, T3 i32, T4 i64] func(context.Context, api.Module, T0, T1, T2, T3, T4)
 
 func (fn funcVIIIIJ[T0, T1, T2, T3, T4]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	_ = stack[4] // prevent bounds check on every slice access
 	fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3]), T4(stack[4]))
 }
 
@@ -104,6 +109,7 @@ func ExportFuncII[TR, T0 i32](mod wazero.HostModuleBuilder, name string, fn func
 type funcIII[TR, T0, T1 i32] func(context.Context, api.Module, T0, T1) TR
 
 func (fn funcIII[TR, T0, T1]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	_ = stack[1] // prevent bounds check on every slice access
 	stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1])))
 }
 
@@ -117,6 +123,7 @@ func ExportFuncIII[TR, T0, T1 i32](mod wazero.HostModuleBuilder, name string, fn
 type funcIIII[TR, T0, T1, T2 i32] func(context.Context, api.Module, T0, T1, T2) TR
 
 func (fn funcIIII[TR, T0, T1, T2]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	_ = stack[2] // prevent bounds check on every slice access
 	stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2])))
 }
 
@@ -130,6 +137,7 @@ func ExportFuncIIII[TR, T0, T1, T2 i32](mod wazero.HostModuleBuilder, name strin
 type funcIIIII[TR, T0, T1, T2, T3 i32] func(context.Context, api.Module, T0, T1, T2, T3) TR
 
 func (fn funcIIIII[TR, T0, T1, T2, T3]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	_ = stack[3] // prevent bounds check on every slice access
 	stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3])))
 }
 
@@ -143,6 +151,7 @@ func ExportFuncIIIII[TR, T0, T1, T2, T3 i32](mod wazero.HostModuleBuilder, name
 type funcIIIIII[TR, T0, T1, T2, T3, T4 i32] func(context.Context, api.Module, T0, T1, T2, T3, T4) TR
 
 func (fn funcIIIIII[TR, T0, T1, T2, T3, T4]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	_ = stack[4] // prevent bounds check on every slice access
 	stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3]), T4(stack[4])))
 }
 
@@ -156,6 +165,7 @@ func ExportFuncIIIIII[TR, T0, T1, T2, T3, T4 i32](mod wazero.HostModuleBuilder,
 type funcIIIIIII[TR, T0, T1, T2, T3, T4, T5 i32] func(context.Context, api.Module, T0, T1, T2, T3, T4, T5) TR
 
 func (fn funcIIIIIII[TR, T0, T1, T2, T3, T4, T5]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	_ = stack[5] // prevent bounds check on every slice access
 	stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3]), T4(stack[4]), T5(stack[5])))
 }
 
@@ -169,6 +179,7 @@ func ExportFuncIIIIIII[TR, T0, T1, T2, T3, T4, T5 i32](mod wazero.HostModuleBuil
 type funcIIIIJ[TR, T0, T1, T2 i32, T3 i64] func(context.Context, api.Module, T0, T1, T2, T3) TR
 
 func (fn funcIIIIJ[TR, T0, T1, T2, T3]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	_ = stack[3] // prevent bounds check on every slice access
 	stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3])))
 }
 
@@ -182,6 +193,7 @@ func ExportFuncIIIIJ[TR, T0, T1, T2 i32, T3 i64](mod wazero.HostModuleBuilder, n
 type funcIIJ[TR, T0 i32, T1 i64] func(context.Context, api.Module, T0, T1) TR
 
 func (fn funcIIJ[TR, T0, T1]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	_ = stack[1] // prevent bounds check on every slice access
 	stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1])))
 }
 

internal/util/handle.go

@@ -35,17 +35,22 @@ func DelHandle(ctx context.Context, id uint32) error {
 	s := ctx.Value(moduleKey{}).(*moduleState)
 	a := s.handles[^id]
 	s.handles[^id] = nil
-	s.holes++
+	if l := uint32(len(s.handles)); l == ^id {
+		s.handles = s.handles[:l-1]
+	} else {
+		s.holes++
+	}
 	if c, ok := a.(io.Closer); ok {
 		return c.Close()
 	}
 	return nil
 }
 
-func AddHandle(ctx context.Context, a any) (id uint32) {
+func AddHandle(ctx context.Context, a any) uint32 {
 	if a == nil {
 		panic(NilErr)
 	}
+
 	s := ctx.Value(moduleKey{}).(*moduleState)
 
 	// Find an empty slot.

internal/util/mmap.go

@@ -1,4 +1,4 @@
-//go:build unix && (amd64 || arm64 || riscv64) && !(sqlite3_noshm || sqlite3_nosys)
+//go:build unix && (amd64 || arm64 || riscv64 || ppc64le) && !(sqlite3_noshm || sqlite3_nosys)
 
 package util
 

internal/util/mmap_other.go

@@ -1,4 +1,4 @@
-//go:build !unix || !(amd64 || arm64 || riscv64) || sqlite3_noshm || sqlite3_nosys
+//go:build !unix || !(amd64 || arm64 || riscv64 || ppc64le) || sqlite3_noshm || sqlite3_nosys
 
 package util
 

internal/util/set.go

@@ -0,0 +1,12 @@
+package util
+
+type Set[E comparable] map[E]struct{}
+
+func (s Set[E]) Add(v E) {
+	s[v] = struct{}{}
+}
+
+func (s Set[E]) Contains(v E) bool {
+	_, ok := s[v]
+	return ok
+}

quote.go

@@ -3,6 +3,7 @@ package sqlite3
 import (
 	"bytes"
 	"math"
+	"reflect"
 	"strconv"
 	"strings"
 	"time"
@@ -13,6 +14,9 @@ import (
 
 // Quote escapes and quotes a value
 // making it safe to embed in SQL text.
+// Strings with embedded NUL characters are truncated.
+//
+// https://sqlite.org/lang_corefunc.html#quote
 func Quote(value any) string {
 	switch v := value.(type) {
 	case nil:
@@ -42,8 +46,8 @@ func Quote(value any) string {
 		return "'" + v.Format(time.RFC3339Nano) + "'"
 
 	case string:
-		if strings.IndexByte(v, 0) >= 0 {
-			break
+		if i := strings.IndexByte(v, 0); i >= 0 {
+			v = v[:i]
 		}
 
 		buf := make([]byte, 2+len(v)+strings.Count(v, "'"))
@@ -57,13 +61,13 @@ func Quote(value any) string {
 			buf[i] = b
 			i += 1
 		}
-		buf[i] = '\''
+		buf[len(buf)-1] = '\''
 		return unsafe.String(&buf[0], len(buf))
 
 	case []byte:
 		buf := make([]byte, 3+2*len(v))
-		buf[0] = 'x'
 		buf[1] = '\''
+		buf[0] = 'x'
 		i := 2
 		for _, b := range v {
 			const hex = "0123456789ABCDEF"
@@ -71,26 +75,50 @@ func Quote(value any) string {
 			buf[i+1] = hex[b%16]
 			i += 2
 		}
-		buf[i] = '\''
+		buf[len(buf)-1] = '\''
 		return unsafe.String(&buf[0], len(buf))
 
 	case ZeroBlob:
-		if v > ZeroBlob(1e9-3)/2 {
-			break
-		}
-
 		buf := bytes.Repeat([]byte("0"), int(3+2*int64(v)))
-		buf[0] = 'x'
 		buf[1] = '\''
+		buf[0] = 'x'
 		buf[len(buf)-1] = '\''
 		return unsafe.String(&buf[0], len(buf))
 	}
 
+	v := reflect.ValueOf(value)
+	k := v.Kind()
+
+	if k == reflect.Interface || k == reflect.Pointer {
+		if v.IsNil() {
+			return "NULL"
+		}
+		v = v.Elem()
+		k = v.Kind()
+	}
+
+	switch {
+	case v.CanInt():
+		return strconv.FormatInt(v.Int(), 10)
+	case v.CanUint():
+		return strconv.FormatUint(v.Uint(), 10)
+	case v.CanFloat():
+		return Quote(v.Float())
+	case k == reflect.Bool:
+		return Quote(v.Bool())
+	case k == reflect.String:
+		return Quote(v.String())
+	case (k == reflect.Slice || k == reflect.Array && v.CanAddr()) &&
+		v.Type().Elem().Kind() == reflect.Uint8:
+		return Quote(v.Bytes())
+	}
+
 	panic(util.ValueErr)
 }
 
 // QuoteIdentifier escapes and quotes an identifier
 // making it safe to embed in SQL text.
+// Strings with embedded NUL characters panic.
 func QuoteIdentifier(id string) string {
 	if strings.IndexByte(id, 0) >= 0 {
 		panic(util.ValueErr)
@@ -107,6 +135,6 @@ func QuoteIdentifier(id string) string {
 		buf[i] = b
 		i += 1
 	}
-	buf[i] = '"'
+	buf[len(buf)-1] = '"'
 	return unsafe.String(&buf[0], len(buf))
 }

sqlite.go

@@ -86,7 +86,6 @@ type sqlite struct {
 		mask uint32
 	}
 	stack [9]uint64
-	freer uint32
 }
 
 func instantiateSQLite() (sqlt *sqlite, err error) {
@@ -102,14 +101,7 @@ func instantiateSQLite() (sqlt *sqlite, err error) {
 	if err != nil {
 		return nil, err
 	}
-
-	global := sqlt.mod.ExportedGlobal("malloc_destructor")
-	if global == nil {
-		return nil, util.BadBinaryErr
-	}
-
-	sqlt.freer = util.ReadUint32(sqlt.mod, uint32(global.Get()))
-	if sqlt.freer == 0 {
+	if sqlt.getfn("sqlite3_progress_handler_go") == nil {
 		return nil, util.BadBinaryErr
 	}
 	return sqlt, nil
@@ -139,7 +131,7 @@ func (sqlt *sqlite) error(rc uint64, handle uint32, sql ...string) error {
 			err.msg = util.ReadString(sqlt.mod, uint32(r), _MAX_LENGTH)
 		}
 
-		if sql != nil {
+		if len(sql) != 0 {
 			if r := sqlt.call("sqlite3_error_offset", uint64(handle)); r != math.MaxUint32 {
 				err.sql = sql[0][r:]
 			}
@@ -196,14 +188,19 @@ func (sqlt *sqlite) free(ptr uint32) {
 	if ptr == 0 {
 		return
 	}
-	sqlt.call("free", uint64(ptr))
+	sqlt.call("sqlite3_free", uint64(ptr))
 }
 
 func (sqlt *sqlite) new(size uint64) uint32 {
-	if size > _MAX_ALLOCATION_SIZE {
+	ptr := uint32(sqlt.call("sqlite3_malloc64", size))
+	if ptr == 0 && size != 0 {
 		panic(util.OOMErr)
 	}
-	ptr := uint32(sqlt.call("malloc", size))
+	return ptr
+}
+
+func (sqlt *sqlite) realloc(ptr uint32, size uint64) uint32 {
+	ptr = uint32(sqlt.call("sqlite3_realloc64", uint64(ptr), size))
 	if ptr == 0 && size != 0 {
 		panic(util.OOMErr)
 	}
@@ -214,7 +211,11 @@ func (sqlt *sqlite) newBytes(b []byte) uint32 {
 	if (*[0]byte)(b) == nil {
 		return 0
 	}
-	ptr := sqlt.new(uint64(len(b)))
+	size := len(b)
+	if size == 0 {
+		size = 1
+	}
+	ptr := sqlt.new(uint64(size))
 	util.WriteBytes(sqlt.mod, ptr, b)
 	return ptr
 }
@@ -300,7 +301,7 @@ func (a *arena) string(s string) uint32 {
 
 func exportCallbacks(env wazero.HostModuleBuilder) wazero.HostModuleBuilder {
 	util.ExportFuncII(env, "go_progress_handler", progressCallback)
-	util.ExportFuncIIII(env, "go_busy_timeout", timeoutCallback)
+	util.ExportFuncIII(env, "go_busy_timeout", timeoutCallback)
 	util.ExportFuncIII(env, "go_busy_handler", busyCallback)
 	util.ExportFuncII(env, "go_commit_hook", commitCallback)
 	util.ExportFuncVI(env, "go_rollback_hook", rollbackCallback)

sqlite3/bind.c

@@ -0,0 +1,13 @@
+#include <stdlib.h>
+
+#include "sqlite3.h"
+
+int sqlite3_bind_text_go(sqlite3_stmt *stmt, int i, const char *zData,
+                         sqlite3_uint64 nData) {
+  return sqlite3_bind_text64(stmt, i, zData, nData, &sqlite3_free, SQLITE_UTF8);
+}
+
+int sqlite3_bind_blob_go(sqlite3_stmt *stmt, int i, const char *zData,
+                         sqlite3_uint64 nData) {
+  return sqlite3_bind_blob64(stmt, i, zData, nData, &sqlite3_free);
+}

sqlite3/column.c

@@ -22,6 +22,7 @@ int sqlite3_columns_go(sqlite3_stmt *stmt, int nCol, char *aType,
     switch (aType[i] = sqlite3_column_type(stmt, i)) {
       default:  // SQLITE_NULL
         aData[i] = (union sqlite3_data){};
+        continue;
       case SQLITE_INTEGER:
         aData[i].i = sqlite3_column_int64(stmt, i);
         continue;

sqlite3/download.sh

@@ -18,6 +18,7 @@ curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/decimal.
 curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/ieee754.c"
 curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/regexp.c"
 curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/series.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/spellfix.c"
 curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/uint.c"
 cd ~-
 

sqlite3/func.c

@@ -53,6 +53,9 @@ int sqlite3_collation_needed_go(sqlite3 *db, bool enable) {
 }
 
 int sqlite3_create_collation_go(sqlite3 *db, const char *name, go_handle app) {
+  if (app == NULL) {
+    return sqlite3_create_collation_v2(db, name, SQLITE_UTF8, NULL, NULL, NULL);
+  }
   int rc = sqlite3_create_collation_v2(db, name, SQLITE_UTF8, app, go_compare,
                                        go_destroy);
   if (rc) go_destroy(app);
@@ -61,6 +64,10 @@ int sqlite3_create_collation_go(sqlite3 *db, const char *name, go_handle app) {
 
 int sqlite3_create_function_go(sqlite3 *db, const char *name, int argc,
                                int flags, go_handle app) {
+  if (app == NULL) {
+    return sqlite3_create_function_v2(db, name, argc, SQLITE_UTF8 | flags, NULL,
+                                      NULL, NULL, NULL, NULL);
+  }
   return sqlite3_create_function_v2(db, name, argc, SQLITE_UTF8 | flags, app,
                                     go_func_wrapper, /*step=*/NULL,
                                     /*final=*/NULL, go_destroy);
@@ -68,6 +75,10 @@ int sqlite3_create_function_go(sqlite3 *db, const char *name, int argc,
 
 int sqlite3_create_aggregate_function_go(sqlite3 *db, const char *name,
                                          int argc, int flags, go_handle app) {
+  if (app == NULL) {
+    return sqlite3_create_function_v2(db, name, argc, SQLITE_UTF8 | flags, NULL,
+                                      NULL, NULL, NULL, NULL);
+  }
   return sqlite3_create_function_v2(db, name, argc, SQLITE_UTF8 | flags, app,
                                     /*func=*/NULL, go_step_wrapper,
                                     go_final_wrapper, go_destroy);
@@ -75,6 +86,10 @@ int sqlite3_create_aggregate_function_go(sqlite3 *db, const char *name,
 
 int sqlite3_create_window_function_go(sqlite3 *db, const char *name, int argc,
                                       int flags, go_handle app) {
+  if (app == NULL) {
+    return sqlite3_create_window_function(db, name, argc, SQLITE_UTF8 | flags,
+                                          NULL, NULL, NULL, NULL, NULL, NULL);
+  }
   return sqlite3_create_window_function(
       db, name, argc, SQLITE_UTF8 | flags, app, go_step_wrapper,
       go_final_wrapper, go_value_wrapper, go_inverse_wrapper, go_destroy);

sqlite3/hooks.c

@@ -4,7 +4,7 @@
 
 int go_progress_handler(void *);
 int go_busy_handler(void *, int);
-int go_busy_timeout(void *, int count, int tmout);
+int go_busy_timeout(int count, int tmout);
 
 int go_commit_hook(void *);
 void go_rollback_hook(void *);
@@ -20,7 +20,7 @@ unsigned int go_autovacuum_pages(void *, const char *, unsigned int,
                                  unsigned int, unsigned int);
 
 void sqlite3_progress_handler_go(sqlite3 *db, int n) {
-  sqlite3_progress_handler(db, n, go_progress_handler, /*arg=*/db);
+  sqlite3_progress_handler(db, n, go_progress_handler, /*arg=*/NULL);
 }
 
 int sqlite3_busy_handler_go(sqlite3 *db, bool enable) {
@@ -57,15 +57,16 @@ int sqlite3_config_log_go(bool enable) {
 }
 
 int sqlite3_autovacuum_pages_go(sqlite3 *db, go_handle app) {
-  int rc = sqlite3_autovacuum_pages(db, go_autovacuum_pages, app, go_destroy);
-  if (rc) go_destroy(app);
-  return rc;
+  if (app == NULL) {
+    return sqlite3_autovacuum_pages(db, NULL, NULL, NULL);
+  }
+  return sqlite3_autovacuum_pages(db, go_autovacuum_pages, app, go_destroy);
 }
 
 #ifndef sqliteBusyCallback
 
 static int sqliteBusyCallback(sqlite3 *db, int count) {
-  return go_busy_timeout(db, count, db->busyTimeout);
+  return go_busy_timeout(count, db->busyTimeout);
 }
 
 #endif

sqlite3/long_double.patch

@@ -0,0 +1,29 @@
+--- sqlite3.c.orig
++++ sqlite3.c
+@@ -35561,7 +35561,7 @@
+ 
+   if( e==0 ){
+     *pResult = s;
+-  }else if( sqlite3Config.bUseLongDouble ){
++  }else if( sizeof(LONGDOUBLE_TYPE)>8 && sqlite3Config.bUseLongDouble ){
+     LONGDOUBLE_TYPE r = (LONGDOUBLE_TYPE)s;
+     if( e>0 ){
+       while( e>=100  ){ e-=100; r *= 1.0e+100L; }
+@@ -35967,7 +35967,7 @@
+   /* Multiply r by powers of ten until it lands somewhere in between
+   ** 1.0e+19 and 1.0e+17.
+   */
+-  if( sqlite3Config.bUseLongDouble ){
++  if( sizeof(LONGDOUBLE_TYPE)>8 && sqlite3Config.bUseLongDouble ){
+     LONGDOUBLE_TYPE rr = r;
+     if( rr>=1.0e+19 ){
+       while( rr>=1.0e+119L ){ exp+=100; rr *= 1.0e-100L; }
+@@ -89354,7 +89354,7 @@
+     ** than NULL */
+     return 1;
+   }
+-  if( sqlite3Config.bUseLongDouble ){
++  if( sizeof(LONGDOUBLE_TYPE)>8 && sqlite3Config.bUseLongDouble ){
+     LONGDOUBLE_TYPE x = (LONGDOUBLE_TYPE)i;
+     testcase( x<r );
+     testcase( x>r );

sqlite3/main.c

@@ -7,18 +7,19 @@
 #include "ext/ieee754.c"
 #include "ext/regexp.c"
 #include "ext/series.c"
+#include "ext/spellfix.c"
 #include "ext/uint.c"
 // Bindings
+#include "bind.c"
 #include "column.c"
 #include "func.c"
 #include "hooks.c"
 #include "pointer.c"
+#include "result.c"
 #include "time.c"
 #include "vfs.c"
 #include "vtab.c"
 
-sqlite3_destructor_type malloc_destructor = &free;
-
 __attribute__((constructor)) void init() {
   sqlite3_initialize();
   sqlite3_auto_extension((void (*)(void))sqlite3_base_init);
@@ -26,6 +27,7 @@ __attribute__((constructor)) void init() {
   sqlite3_auto_extension((void (*)(void))sqlite3_ieee_init);
   sqlite3_auto_extension((void (*)(void))sqlite3_regexp_init);
   sqlite3_auto_extension((void (*)(void))sqlite3_series_init);
+  sqlite3_auto_extension((void (*)(void))sqlite3_spellfix_init);
   sqlite3_auto_extension((void (*)(void))sqlite3_uint_init);
   sqlite3_auto_extension((void (*)(void))sqlite3_time_init);
 }

sqlite3/result.c

@@ -0,0 +1,14 @@
+#include <math.h>
+#include <stdlib.h>
+
+#include "sqlite3.h"
+
+void sqlite3_result_text_go(sqlite3_context *ctx, const char *zData,
+                            sqlite3_uint64 nData) {
+  sqlite3_result_text64(ctx, zData, nData, &sqlite3_free, SQLITE_UTF8);
+}
+
+void sqlite3_result_blob_go(sqlite3_context *ctx, const void *zData,
+                            sqlite3_uint64 nData) {
+  sqlite3_result_blob64(ctx, zData, nData, &sqlite3_free);
+}

sqlite3/sqlite_opt.h

@@ -2,7 +2,6 @@
 
 #define SQLITE_DQS 0
 #define SQLITE_THREADSAFE 0
-#define SQLITE_DEFAULT_MEMSTATUS 0
 #define SQLITE_DEFAULT_WAL_SYNCHRONOUS 1
 #define SQLITE_LIKE_DOESNT_MATCH_BLOBS
 #define SQLITE_MAX_EXPR_DEPTH 0
@@ -13,6 +12,7 @@
 #define SQLITE_OMIT_AUTOINIT
 
 // We need these:
+// #define SQLITE_DEFAULT_MEMSTATUS 0
 // #define SQLITE_OMIT_DECLTYPE
 // #define SQLITE_OMIT_PROGRESS_CALLBACK
 
@@ -24,6 +24,7 @@
 #define SQLITE_ENABLE_ATOMIC_WRITE
 #define SQLITE_ENABLE_BATCH_ATOMIC_WRITE
 #define SQLITE_ENABLE_COLUMN_METADATA
+#define SQLITE_ENABLE_SETLK_TIMEOUT 2
 #define SQLITE_ENABLE_STAT4 1
 
 // We have our own memdb VFS.

sqlite3/vtab.c

@@ -163,6 +163,10 @@ static int go_vtab_shadown_name_wrapper(const char *zName) { return true; }
 
 int sqlite3_create_module_go(sqlite3 *db, const char *zName, int flags,
                              go_handle handle) {
+  if (handle == NULL) {
+    return sqlite3_create_module_v2(db, zName, NULL, NULL, NULL);
+  }
+
   struct go_module *mod = malloc(sizeof(struct go_module));
   if (mod == NULL) {
     go_destroy(handle);

sqlite_test.go

@@ -3,7 +3,6 @@ package sqlite3
 import (
 	"bytes"
 	"math"
-	"os"
 	"testing"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
@@ -39,7 +38,7 @@ func Test_sqlite_call_closed(t *testing.T) {
 	sqlite.close()
 
 	defer func() { _ = recover() }()
-	sqlite.call("free")
+	sqlite.call("sqlite3_free")
 	t.Error("want panic")
 }
 
@@ -57,19 +56,6 @@ func Test_sqlite_new(t *testing.T) {
 		sqlite.new(math.MaxUint32)
 		t.Error("want panic")
 	})
-
-	t.Run("_MAX_ALLOCATION_SIZE", func(t *testing.T) {
-		if testing.Short() {
-			t.Skip("skipping in short mode")
-		}
-		if os.Getenv("CI") != "" {
-			t.Skip("skipping in CI")
-		}
-		defer func() { _ = recover() }()
-		sqlite.new(_MAX_ALLOCATION_SIZE)
-		sqlite.new(_MAX_ALLOCATION_SIZE)
-		t.Error("want panic")
-	})
 }
 
 func Test_sqlite_newArena(t *testing.T) {

stmt.go

@@ -30,12 +30,13 @@ func (s *Stmt) Close() error {
 	}
 
 	r := s.c.call("sqlite3_finalize", uint64(s.handle))
-	for i := range s.c.stmts {
-		if s == s.c.stmts[i] {
-			l := len(s.c.stmts) - 1
-			s.c.stmts[i] = s.c.stmts[l]
-			s.c.stmts[l] = nil
-			s.c.stmts = s.c.stmts[:l]
+	stmts := s.c.stmts
+	for i := range stmts {
+		if s == stmts[i] {
+			l := len(stmts) - 1
+			stmts[i] = stmts[l]
+			stmts[l] = nil
+			s.c.stmts = stmts[:l]
 			break
 		}
 	}
@@ -105,7 +106,7 @@ func (s *Stmt) Busy() bool {
 //
 // https://sqlite.org/c3ref/step.html
 func (s *Stmt) Step() bool {
-	s.c.checkInterrupt()
+	s.c.checkInterrupt(s.c.handle)
 	r := s.c.call("sqlite3_step", uint64(s.handle))
 	switch r {
 	case _ROW:
@@ -246,10 +247,9 @@ func (s *Stmt) BindText(param int, value string) error {
 		return TOOBIG
 	}
 	ptr := s.c.newString(value)
-	r := s.c.call("sqlite3_bind_text64",
+	r := s.c.call("sqlite3_bind_text_go",
 		uint64(s.handle), uint64(param),
-		uint64(ptr), uint64(len(value)),
-		uint64(s.c.freer), _UTF8)
+		uint64(ptr), uint64(len(value)))
 	return s.c.error(r)
 }
 
@@ -262,10 +262,9 @@ func (s *Stmt) BindRawText(param int, value []byte) error {
 		return TOOBIG
 	}
 	ptr := s.c.newBytes(value)
-	r := s.c.call("sqlite3_bind_text64",
+	r := s.c.call("sqlite3_bind_text_go",
 		uint64(s.handle), uint64(param),
-		uint64(ptr), uint64(len(value)),
-		uint64(s.c.freer), _UTF8)
+		uint64(ptr), uint64(len(value)))
 	return s.c.error(r)
 }
 
@@ -279,10 +278,9 @@ func (s *Stmt) BindBlob(param int, value []byte) error {
 		return TOOBIG
 	}
 	ptr := s.c.newBytes(value)
-	r := s.c.call("sqlite3_bind_blob64",
+	r := s.c.call("sqlite3_bind_blob_go",
 		uint64(s.handle), uint64(param),
-		uint64(ptr), uint64(len(value)),
-		uint64(s.c.freer))
+		uint64(ptr), uint64(len(value)))
 	return s.c.error(r)
 }
 
@@ -335,10 +333,9 @@ func (s *Stmt) bindRFC3339Nano(param int, value time.Time) error {
 	buf := util.View(s.c.mod, ptr, maxlen)
 	buf = value.AppendFormat(buf[:0], time.RFC3339Nano)
 
-	r := s.c.call("sqlite3_bind_text64",
+	r := s.c.call("sqlite3_bind_text_go",
 		uint64(s.handle), uint64(param),
-		uint64(ptr), uint64(len(buf)),
-		uint64(s.c.freer), _UTF8)
+		uint64(ptr), uint64(len(buf)))
 	return s.c.error(r)
 }
 
@@ -380,6 +377,15 @@ func (s *Stmt) BindValue(param int, value Value) error {
 	return s.c.error(r)
 }
 
+// DataCount resets the number of columns in a result set.
+//
+// https://sqlite.org/c3ref/data_count.html
+func (s *Stmt) DataCount() int {
+	r := s.c.call("sqlite3_data_count",
+		uint64(s.handle))
+	return int(int32(r))
+}
+
 // ColumnCount returns the number of columns in a result set.
 //
 // https://sqlite.org/c3ref/column_count.html
@@ -634,7 +640,7 @@ func (s *Stmt) Columns(dest []any) error {
 	defer s.c.arena.mark()()
 	count := uint64(len(dest))
 	typePtr := s.c.arena.new(count)
-	dataPtr := s.c.arena.new(8 * count)
+	dataPtr := s.c.arena.new(count * 8)
 
 	r := s.c.call("sqlite3_columns_go",
 		uint64(s.handle), count, uint64(typePtr), uint64(dataPtr))
@@ -643,26 +649,31 @@ func (s *Stmt) Columns(dest []any) error {
 	}
 
 	types := util.View(s.c.mod, typePtr, count)
+
+	// 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] = int64(util.ReadUint64(s.c.mod, dataPtr+8*uint32(i)))
-			continue
+			dest[i] = int64(util.ReadUint64(s.c.mod, dataPtr))
 		case byte(FLOAT):
-			dest[i] = util.ReadFloat64(s.c.mod, dataPtr+8*uint32(i))
-			continue
+			dest[i] = util.ReadFloat64(s.c.mod, dataPtr)
 		case byte(NULL):
 			dest[i] = nil
-			continue
-		}
-		ptr := util.ReadUint32(s.c.mod, dataPtr+8*uint32(i)+0)
-		len := util.ReadUint32(s.c.mod, dataPtr+8*uint32(i)+4)
-		buf := util.View(s.c.mod, ptr, uint64(len))
-		if types[i] == byte(TEXT) {
-			dest[i] = string(buf)
-		} else {
-			dest[i] = buf
+		default:
+			ptr := util.ReadUint32(s.c.mod, dataPtr+0)
+			len := util.ReadUint32(s.c.mod, dataPtr+4)
+			buf := util.View(s.c.mod, ptr, uint64(len))
+			if types[i] == byte(TEXT) {
+				dest[i] = string(buf)
+			} else {
+				dest[i] = buf
+			}
 		}
+		dataPtr += 8
 	}
 	return nil
 }

tests/config_test.go

@@ -0,0 +1,427 @@
+package tests
+
+import (
+	"errors"
+	"math"
+	"net/url"
+	"path/filepath"
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/vfs"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
+)
+
+func TestConn_Config(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	o, err := db.Config(sqlite3.DBCONFIG_DEFENSIVE)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if o != false {
+		t.Error("want false")
+	}
+
+	o, err = db.Config(sqlite3.DBCONFIG_DEFENSIVE, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if o != true {
+		t.Error("want true")
+	}
+
+	o, err = db.Config(sqlite3.DBCONFIG_DEFENSIVE)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if o != true {
+		t.Error("want true")
+	}
+
+	o, err = db.Config(sqlite3.DBCONFIG_DEFENSIVE, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if o != false {
+		t.Error("want false")
+	}
+
+	o, err = db.Config(sqlite3.DBCONFIG_DEFENSIVE)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if o != false {
+		t.Error("want false")
+	}
+}
+
+func TestConn_ConfigLog(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	var code sqlite3.ExtendedErrorCode
+	err = db.ConfigLog(func(c sqlite3.ExtendedErrorCode, msg string) {
+		t.Log(msg)
+		code = c
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	db.Prepare(`SELECT * FRM sqlite_schema`)
+
+	if code != sqlite3.ExtendedErrorCode(sqlite3.ERROR) {
+		t.Error("want sqlite3.ERROR")
+	}
+}
+
+func TestConn_FileControl(t *testing.T) {
+	t.Parallel()
+
+	file := filepath.Join(t.TempDir(), "test.db")
+	db, err := sqlite3.Open(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	t.Run("MISUSE", func(t *testing.T) {
+		_, err := db.FileControl("main", 0)
+		if !errors.Is(err, sqlite3.MISUSE) {
+			t.Errorf("got %v, want MISUSE", err)
+		}
+	})
+	t.Run("FCNTL_RESET_CACHE", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_RESET_CACHE)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != nil {
+			t.Errorf("got %v, want nil", o)
+		}
+	})
+
+	t.Run("FCNTL_PERSIST_WAL", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_PERSIST_WAL)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != false {
+			t.Errorf("got %v, want false", o)
+		}
+
+		o, err = db.FileControl("", sqlite3.FCNTL_PERSIST_WAL, true)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != true {
+			t.Errorf("got %v, want true", o)
+		}
+
+		o, err = db.FileControl("", sqlite3.FCNTL_PERSIST_WAL)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != true {
+			t.Errorf("got %v, want true", o)
+		}
+	})
+
+	t.Run("FCNTL_CHUNK_SIZE", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_CHUNK_SIZE, 1024*1024)
+		if !errors.Is(err, sqlite3.NOTFOUND) {
+			t.Errorf("got %v, want NOTFOUND", err)
+		}
+		if o != nil {
+			t.Errorf("got %v, want nil", o)
+		}
+	})
+
+	t.Run("FCNTL_RESERVE_BYTES", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_RESERVE_BYTES, 4)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != 0 {
+			t.Errorf("got %v, want 0", o)
+		}
+
+		o, err = db.FileControl("", sqlite3.FCNTL_RESERVE_BYTES)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != 4 {
+			t.Errorf("got %v, want 4", o)
+		}
+	})
+
+	t.Run("FCNTL_DATA_VERSION", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_DATA_VERSION)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != uint32(2) {
+			t.Errorf("got %v, want 2", o)
+		}
+	})
+
+	t.Run("FCNTL_VFS_POINTER", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_VFS_POINTER)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != vfs.Find("os") {
+			t.Errorf("got %v, want os", o)
+		}
+	})
+
+	t.Run("FCNTL_FILE_POINTER", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_FILE_POINTER)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, ok := o.(vfs.File); !ok {
+			t.Errorf("got %v, want File", o)
+		}
+	})
+
+	t.Run("FCNTL_JOURNAL_POINTER", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_JOURNAL_POINTER)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != nil {
+			t.Errorf("got %v, want nil", o)
+		}
+	})
+
+	t.Run("FCNTL_LOCKSTATE", func(t *testing.T) {
+		if !vfs.SupportsFileLocking {
+			t.Skip("skipping without locks")
+		}
+
+		txn, err := db.BeginExclusive()
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer txn.End(&err)
+
+		o, err := db.FileControl("", sqlite3.FCNTL_LOCKSTATE)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != vfs.LOCK_EXCLUSIVE {
+			t.Errorf("got %v, want LOCK_EXCLUSIVE", o)
+		}
+	})
+}
+
+func TestConn_Limit(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	l := db.Limit(sqlite3.LIMIT_COLUMN, -1)
+	if l != 2000 {
+		t.Errorf("got %d, want 2000", l)
+	}
+
+	l = db.Limit(sqlite3.LIMIT_COLUMN, 100)
+	if l != 2000 {
+		t.Errorf("got %d, want 2000", l)
+	}
+
+	l = db.Limit(sqlite3.LIMIT_COLUMN, -1)
+	if l != 100 {
+		t.Errorf("got %d, want 100", l)
+	}
+
+	l = db.Limit(math.MaxUint32, -1)
+	if l != -1 {
+		t.Errorf("got %d, want -1", l)
+	}
+}
+
+func TestConn_SetAuthorizer(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.SetAuthorizer(func(action sqlite3.AuthorizerActionCode, name3rd, name4th, schema, nameInner string) sqlite3.AuthorizerReturnCode {
+		if action != sqlite3.AUTH_PRAGMA {
+			t.Errorf("got %v, want PRAGMA", action)
+		}
+		if name3rd != "busy_timeout" {
+			t.Errorf("got %q, want busy_timeout", name3rd)
+		}
+		if name4th != "5000" {
+			t.Errorf("got %q, want 5000", name4th)
+		}
+		if schema != "main" {
+			t.Errorf("got %q, want main", schema)
+		}
+		return sqlite3.AUTH_DENY
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`PRAGMA main.busy_timeout=5000`)
+	if !errors.Is(err, sqlite3.AUTH) {
+		t.Errorf("got %v, want sqlite3.AUTH", err)
+	}
+}
+
+func TestConn_Trace(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	rows := 0
+	closed := false
+	err = db.Trace(math.MaxUint32, func(evt sqlite3.TraceEvent, a1 any, a2 any) error {
+		switch evt {
+		case sqlite3.TRACE_CLOSE:
+			closed = true
+			_ = a1.(*sqlite3.Conn)
+			return db.Exec(`PRAGMA optimize`)
+		case sqlite3.TRACE_STMT:
+			stmt := a1.(*sqlite3.Stmt)
+			if sql := a2.(string); sql != stmt.SQL() {
+				t.Errorf("got %q, want %q", sql, stmt.SQL())
+			}
+			if sql := stmt.ExpandedSQL(); sql != `SELECT 1` {
+				t.Errorf("got %q", sql)
+			}
+		case sqlite3.TRACE_PROFILE:
+			_ = a1.(*sqlite3.Stmt)
+			if ns := a2.(int64); ns < 0 {
+				t.Errorf("got %d", ns)
+			}
+		case sqlite3.TRACE_ROW:
+			_ = a1.(*sqlite3.Stmt)
+			if a2 != nil {
+				t.Errorf("got %v", a2)
+			}
+			rows++
+		}
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT ?`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = stmt.BindInt(1, 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = stmt.Exec()
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = stmt.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rows != 1 {
+		t.Error("want 1")
+	}
+
+	err = db.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !closed {
+		t.Error("want closed")
+	}
+}
+
+func TestConn_AutoVacuumPages(t *testing.T) {
+	t.Parallel()
+	tmp := memdb.TestDB(t, url.Values{
+		"_pragma": {"auto_vacuum(full)"},
+	})
+
+	db, err := sqlite3.Open(tmp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.AutoVacuumPages(func(schema string, dbPages, freePages, bytesPerPage uint) uint {
+		return freePages
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`CREATE TABLE test (col)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`INSERT INTO test VALUES (zeroblob(1024*1024))`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`DROP TABLE test`)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestConn_memoryLimit(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	n := db.HardHeapLimit(-1)
+	if n != 0 {
+		t.Fatal("want zero")
+	}
+
+	const limit = 64 * 1024 * 1024
+
+	n = db.SoftHeapLimit(limit)
+	if n != 0 {
+		t.Fatal("want zero")
+	}
+
+	n = db.SoftHeapLimit(-1)
+	if n != limit {
+		t.Fatal("want", limit)
+	}
+}

tests/conn_test.go

@@ -3,8 +3,6 @@ package tests
 import (
 	"context"
 	"errors"
-	"math"
-	"net/url"
 	"os"
 	"path/filepath"
 	"strings"
@@ -13,8 +11,6 @@ import (
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
-	"github.com/ncruces/go-sqlite3/vfs"
-	"github.com/ncruces/go-sqlite3/vfs/memdb"
 	_ "github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
@@ -265,358 +261,6 @@ func TestConn_Prepare_invalid(t *testing.T) {
 	}
 }
 
-func TestConn_Config(t *testing.T) {
-	t.Parallel()
-
-	db, err := sqlite3.Open(":memory:")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db.Close()
-
-	o, err := db.Config(sqlite3.DBCONFIG_DEFENSIVE)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if o != false {
-		t.Error("want false")
-	}
-
-	o, err = db.Config(sqlite3.DBCONFIG_DEFENSIVE, true)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if o != true {
-		t.Error("want true")
-	}
-
-	o, err = db.Config(sqlite3.DBCONFIG_DEFENSIVE)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if o != true {
-		t.Error("want true")
-	}
-
-	o, err = db.Config(sqlite3.DBCONFIG_DEFENSIVE, false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if o != false {
-		t.Error("want false")
-	}
-
-	o, err = db.Config(sqlite3.DBCONFIG_DEFENSIVE)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if o != false {
-		t.Error("want false")
-	}
-}
-
-func TestConn_ConfigLog(t *testing.T) {
-	t.Parallel()
-
-	db, err := sqlite3.Open(":memory:")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db.Close()
-
-	var code sqlite3.ExtendedErrorCode
-	err = db.ConfigLog(func(c sqlite3.ExtendedErrorCode, msg string) {
-		t.Log(msg)
-		code = c
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	db.Prepare(`SELECT * FRM sqlite_schema`)
-
-	if code != sqlite3.ExtendedErrorCode(sqlite3.ERROR) {
-		t.Error("want sqlite3.ERROR")
-	}
-}
-
-func TestConn_FileControl(t *testing.T) {
-	t.Parallel()
-
-	file := filepath.Join(t.TempDir(), "test.db")
-	db, err := sqlite3.Open(file)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db.Close()
-
-	t.Run("MISUSE", func(t *testing.T) {
-		_, err := db.FileControl("main", 0)
-		if !errors.Is(err, sqlite3.MISUSE) {
-			t.Errorf("got %v, want MISUSE", err)
-		}
-	})
-	t.Run("FCNTL_RESET_CACHE", func(t *testing.T) {
-		o, err := db.FileControl("", sqlite3.FCNTL_RESET_CACHE)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if o != nil {
-			t.Errorf("got %v, want nil", o)
-		}
-	})
-
-	t.Run("FCNTL_PERSIST_WAL", func(t *testing.T) {
-		o, err := db.FileControl("", sqlite3.FCNTL_PERSIST_WAL)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if o != false {
-			t.Errorf("got %v, want false", o)
-		}
-
-		o, err = db.FileControl("", sqlite3.FCNTL_PERSIST_WAL, true)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if o != true {
-			t.Errorf("got %v, want true", o)
-		}
-
-		o, err = db.FileControl("", sqlite3.FCNTL_PERSIST_WAL)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if o != true {
-			t.Errorf("got %v, want true", o)
-		}
-	})
-
-	t.Run("FCNTL_CHUNK_SIZE", func(t *testing.T) {
-		o, err := db.FileControl("", sqlite3.FCNTL_CHUNK_SIZE, 1024*1024)
-		if !errors.Is(err, sqlite3.NOTFOUND) {
-			t.Errorf("got %v, want NOTFOUND", err)
-		}
-		if o != nil {
-			t.Errorf("got %v, want nil", o)
-		}
-	})
-
-	t.Run("FCNTL_RESERVE_BYTES", func(t *testing.T) {
-		o, err := db.FileControl("", sqlite3.FCNTL_RESERVE_BYTES, 4)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if o != 0 {
-			t.Errorf("got %v, want 0", o)
-		}
-
-		o, err = db.FileControl("", sqlite3.FCNTL_RESERVE_BYTES)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if o != 4 {
-			t.Errorf("got %v, want 4", o)
-		}
-	})
-
-	t.Run("FCNTL_DATA_VERSION", func(t *testing.T) {
-		o, err := db.FileControl("", sqlite3.FCNTL_DATA_VERSION)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if o != uint32(2) {
-			t.Errorf("got %v, want 2", o)
-		}
-	})
-
-	t.Run("FCNTL_VFS_POINTER", func(t *testing.T) {
-		o, err := db.FileControl("", sqlite3.FCNTL_VFS_POINTER)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if o != vfs.Find("os") {
-			t.Errorf("got %v, want os", o)
-		}
-	})
-
-	t.Run("FCNTL_FILE_POINTER", func(t *testing.T) {
-		o, err := db.FileControl("", sqlite3.FCNTL_FILE_POINTER)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if _, ok := o.(vfs.File); !ok {
-			t.Errorf("got %v, want File", o)
-		}
-	})
-
-	t.Run("FCNTL_JOURNAL_POINTER", func(t *testing.T) {
-		o, err := db.FileControl("", sqlite3.FCNTL_JOURNAL_POINTER)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if o != nil {
-			t.Errorf("got %v, want nil", o)
-		}
-	})
-
-	t.Run("FCNTL_LOCKSTATE", func(t *testing.T) {
-		if !vfs.SupportsFileLocking {
-			t.Skip("skipping without locks")
-		}
-
-		txn, err := db.BeginExclusive()
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer txn.End(&err)
-
-		o, err := db.FileControl("", sqlite3.FCNTL_LOCKSTATE)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if o != vfs.LOCK_EXCLUSIVE {
-			t.Errorf("got %v, want LOCK_EXCLUSIVE", o)
-		}
-	})
-}
-
-func TestConn_Limit(t *testing.T) {
-	t.Parallel()
-
-	db, err := sqlite3.Open(":memory:")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db.Close()
-
-	l := db.Limit(sqlite3.LIMIT_COLUMN, -1)
-	if l != 2000 {
-		t.Errorf("got %d, want 2000", l)
-	}
-
-	l = db.Limit(sqlite3.LIMIT_COLUMN, 100)
-	if l != 2000 {
-		t.Errorf("got %d, want 2000", l)
-	}
-
-	l = db.Limit(sqlite3.LIMIT_COLUMN, -1)
-	if l != 100 {
-		t.Errorf("got %d, want 100", l)
-	}
-
-	l = db.Limit(math.MaxUint32, -1)
-	if l != -1 {
-		t.Errorf("got %d, want -1", l)
-	}
-}
-
-func TestConn_SetAuthorizer(t *testing.T) {
-	t.Parallel()
-
-	db, err := sqlite3.Open(":memory:")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db.Close()
-
-	err = db.SetAuthorizer(func(action sqlite3.AuthorizerActionCode, name3rd, name4th, schema, nameInner string) sqlite3.AuthorizerReturnCode {
-		if action != sqlite3.AUTH_PRAGMA {
-			t.Errorf("got %v, want PRAGMA", action)
-		}
-		if name3rd != "busy_timeout" {
-			t.Errorf("got %q, want busy_timeout", name3rd)
-		}
-		if name4th != "5000" {
-			t.Errorf("got %q, want 5000", name4th)
-		}
-		if schema != "main" {
-			t.Errorf("got %q, want main", schema)
-		}
-		return sqlite3.AUTH_DENY
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = db.Exec(`PRAGMA main.busy_timeout=5000`)
-	if !errors.Is(err, sqlite3.AUTH) {
-		t.Errorf("got %v, want sqlite3.AUTH", err)
-	}
-}
-
-func TestConn_Trace(t *testing.T) {
-	t.Parallel()
-
-	db, err := sqlite3.Open(":memory:")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db.Close()
-
-	rows := 0
-	closed := false
-	err = db.Trace(math.MaxUint32, func(evt sqlite3.TraceEvent, a1 any, a2 any) error {
-		switch evt {
-		case sqlite3.TRACE_CLOSE:
-			closed = true
-			_ = a1.(*sqlite3.Conn)
-			return db.Exec(`PRAGMA optimize`)
-		case sqlite3.TRACE_STMT:
-			stmt := a1.(*sqlite3.Stmt)
-			if sql := a2.(string); sql != stmt.SQL() {
-				t.Errorf("got %q, want %q", sql, stmt.SQL())
-			}
-			if sql := stmt.ExpandedSQL(); sql != `SELECT 1` {
-				t.Errorf("got %q", sql)
-			}
-		case sqlite3.TRACE_PROFILE:
-			_ = a1.(*sqlite3.Stmt)
-			if ns := a2.(int64); ns < 0 {
-				t.Errorf("got %d", ns)
-			}
-		case sqlite3.TRACE_ROW:
-			_ = a1.(*sqlite3.Stmt)
-			if a2 != nil {
-				t.Errorf("got %v", a2)
-			}
-			rows++
-		}
-		return nil
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	stmt, _, err := db.Prepare(`SELECT ?`)
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = stmt.BindInt(1, 1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = stmt.Exec()
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = stmt.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if rows != 1 {
-		t.Error("want 1")
-	}
-
-	err = db.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !closed {
-		t.Error("want closed")
-	}
-}
-
 func TestConn_ReleaseMemory(t *testing.T) {
 	t.Parallel()
 
@@ -727,41 +371,6 @@ func TestConn_DBName(t *testing.T) {
 	}
 }
 
-func TestConn_AutoVacuumPages(t *testing.T) {
-	t.Parallel()
-	tmp := memdb.TestDB(t, url.Values{
-		"_pragma": {"auto_vacuum(full)"},
-	})
-
-	db, err := sqlite3.Open(tmp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db.Close()
-
-	err = db.AutoVacuumPages(func(schema string, dbPages, freePages, bytesPerPage uint) uint {
-		return freePages
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = db.Exec(`CREATE TABLE test (col)`)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = db.Exec(`INSERT INTO test VALUES (zeroblob(1024*1024))`)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = db.Exec(`DROP TABLE test`)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
 func TestConn_Status(t *testing.T) {
 	t.Parallel()
 

tests/driver_test.go

@@ -33,7 +33,7 @@ func TestDriver(t *testing.T) {
 	defer conn.Close()
 
 	res, err := conn.ExecContext(ctx,
-		`CREATE TABLE users (id INT, name VARCHAR(10))`)
+		`CREATE TABLE users (id INTEGER PRIMARY KEY NOT NULL, name VARCHAR(10))`)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -82,11 +82,17 @@ func TestDriver(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if got := typs[0].DatabaseTypeName(); got != "INT" {
-		t.Errorf("got %s, want INT", got)
+	if got := typs[0].DatabaseTypeName(); got != "INTEGER" {
+		t.Errorf("got %s, want INTEGER", got)
 	}
 	if got := typs[1].DatabaseTypeName(); got != "VARCHAR" {
-		t.Errorf("got %s, want INT", got)
+		t.Errorf("got %s, want VARCHAR", got)
+	}
+	if got, ok := typs[0].Nullable(); got || !ok {
+		t.Errorf("got %v/%v, want false/true", got, ok)
+	}
+	if got, ok := typs[1].Nullable(); !got || ok {
+		t.Errorf("got %v/%v, want true/false", got, ok)
 	}
 
 	row := 0

tests/func_test.go

@@ -209,6 +209,24 @@ func TestCreateFunction_error(t *testing.T) {
 	stmt.Step()
 }
 
+func TestCreateFunction_delete(t *testing.T) {
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.CreateFunction("regexp", 2, 0, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`SELECT 'a' REGEXP 'a|b'`)
+	if err == nil {
+		t.Error("want error")
+	}
+}
+
 func TestOverloadFunction(t *testing.T) {
 	t.Parallel()
 

tests/parallel/parallel_test.go

@@ -1,7 +1,10 @@
 package tests
 
 import (
+	"context"
+	"errors"
 	"io"
+	"log"
 	"net/url"
 	"os"
 	"os/exec"
@@ -19,6 +22,20 @@ import (
 	"github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
+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)
+			}
+		})
+	})
+	m.Run()
+}
+
 func Test_parallel(t *testing.T) {
 	if !vfs.SupportsFileLocking {
 		t.Skip("skipping without locks")
@@ -45,12 +62,19 @@ func Test_wal(t *testing.T) {
 		t.Skip("skipping without shared memory")
 	}
 
+	var iter int
+	if testing.Short() {
+		iter = 1000
+	} else {
+		iter = 2500
+	}
+
 	name := "file:" +
 		filepath.ToSlash(filepath.Join(t.TempDir(), "test.db")) +
 		"?_pragma=busy_timeout(10000)" +
 		"&_pragma=journal_mode(wal)" +
 		"&_pragma=synchronous(off)"
-	testParallel(t, name, 1000)
+	testParallel(t, name, iter)
 	testIntegrity(t, name)
 }
 
@@ -108,7 +132,12 @@ func TestMultiProcess(t *testing.T) {
 		"&_pragma=journal_mode(truncate)" +
 		"&_pragma=synchronous(off)"
 
-	cmd := exec.Command(os.Args[0], append(os.Args[1:], "-test.v", "-test.run=TestChildProcess")...)
+	exe, err := os.Executable()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	cmd := exec.Command(exe, append(os.Args[1:], "-test.v", "-test.run=TestChildProcess")...)
 	out, err := cmd.StdoutPipe()
 	if err != nil {
 		t.Fatal(err)
@@ -196,9 +225,13 @@ func testParallel(t testing.TB, name string, n int) {
 		}
 		defer db.Close()
 
-		err = db.BusyHandler(func(count int) (retry bool) {
-			time.Sleep(time.Millisecond)
-			return true
+		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

tests/quote_test.go

@@ -1,6 +1,8 @@
 package tests
 
 import (
+	"database/sql"
+	"encoding/json"
 	"math"
 	"reflect"
 	"testing"
@@ -19,8 +21,8 @@ func TestQuote(t *testing.T) {
 		{`a'bc`, "'a''bc'"},
 		{"\x07bc", "'\abc'"},
 		{"\x1c\n", "'\x1c\n'"},
+		{"\xB0\x00\x0B", "'\xB0'"},
 		{[]byte("\xB0\x00\x0B"), "x'B0000B'"},
-		{"\xB0\x00\x0B", ""},
 
 		{0, "0"},
 		{true, "1"},
@@ -33,7 +35,13 @@ func TestQuote(t *testing.T) {
 		{int64(math.MaxInt64), "9223372036854775807"},
 		{time.Unix(0, 0).UTC(), "'1970-01-01T00:00:00Z'"},
 		{sqlite3.ZeroBlob(4), "x'00000000'"},
-		{sqlite3.ZeroBlob(1e9), ""},
+		{int8(0), "0"},
+		{uint(0), "0"},
+		{float32(0), "0"},
+		{(*string)(nil), "NULL"},
+		{json.Number("0"), "'0'"},
+		{&sql.RawBytes{'0'}, "x'30'"},
+		{t, ""}, // panic
 	}
 
 	for _, tt := range tests {
@@ -62,7 +70,7 @@ func TestQuoteIdentifier(t *testing.T) {
 		{`a'bc`, `"a'bc"`},
 		{"\x07bc", "\"\abc\""},
 		{"\x1c\n", "\"\x1c\n\""},
-		{"\xB0\x00\x0B", ""},
+		{"\xB0\x00\x0B", ""}, // panic
 	}
 
 	for _, tt := range tests {

tests/stmt_test.go

@@ -146,6 +146,12 @@ func TestStmt(t *testing.T) {
 	if got := stmt.ReadOnly(); got != true {
 		t.Error("got false, want true")
 	}
+	if got := stmt.DataCount(); got != 0 {
+		t.Errorf("got %d, want 0", got)
+	}
+	if got := stmt.ColumnCount(); got != 1 {
+		t.Errorf("got %d, want 1", got)
+	}
 	if got := stmt.ColumnName(0); got != "c" {
 		t.Errorf(`got %q, want "c"`, got)
 	}
@@ -503,6 +509,10 @@ func TestStmt(t *testing.T) {
 		}
 	}
 
+	if got := stmt.DataCount(); got != 1 {
+		t.Errorf("got %d, want 1", got)
+	}
+
 	db.Stmts()(func(s *sqlite3.Stmt) bool {
 		if s != stmt {
 			t.Error()

tests/time_test.go

@@ -111,6 +111,7 @@ func TestTimeFormat_Decode(t *testing.T) {
 
 		{sqlite3.TimeFormatDefault, "2013-10-07T04:23:19.12-04:00", reference, 0, offset, false},
 		{sqlite3.TimeFormatDefault, "2013-10-07T08:23:19.12Z", reference, 0, 0, false},
+		{sqlite3.TimeFormatDefault, reference, reference, 0, offset, false},
 		{sqlite3.TimeFormatDefault, false, time.Time{}, 0, 0, true},
 	}
 

tests/vtab_test.go

@@ -0,0 +1,20 @@
+package tests
+
+import (
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+func TestCreateModule_delete(t *testing.T) {
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = sqlite3.CreateModule[sqlite3.VTab](db, "generate_series", nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+}

time.go

@@ -138,6 +138,9 @@ func (f TimeFormat) Encode(t time.Time) any {
 //
 // https://sqlite.org/lang_datefunc.html
 func (f TimeFormat) Decode(v any) (time.Time, error) {
+	if t, ok := v.(time.Time); ok {
+		return t, nil
+	}
 	switch f {
 	// Numeric formats.
 	case TimeFormatJulianDay:

txn.go

@@ -3,7 +3,6 @@ package sqlite3
 import (
 	"context"
 	"errors"
-	"fmt"
 	"math/rand"
 	"runtime"
 	"strconv"
@@ -136,23 +135,21 @@ type Savepoint struct {
 //
 // https://sqlite.org/lang_savepoint.html
 func (c *Conn) Savepoint() Savepoint {
-	// Names can be reused; this makes catching bugs more likely.
-	name := saveptName() + "_" + strconv.Itoa(int(rand.Int31()))
+	name := callerName()
+	if name == "" {
+		name = "sqlite3.Savepoint"
+	}
+	// Names can be reused, but this makes catching bugs more likely.
+	name = QuoteIdentifier(name + "_" + strconv.Itoa(int(rand.Int31())))
 
-	err := c.txnExecInterrupted(fmt.Sprintf("SAVEPOINT %q;", name))
+	err := c.txnExecInterrupted("SAVEPOINT " + name)
 	if err != nil {
 		panic(err)
 	}
 	return Savepoint{c: c, name: name}
 }
 
-func saveptName() (name string) {
-	defer func() {
-		if name == "" {
-			name = "sqlite3.Savepoint"
-		}
-	}()
-
+func callerName() (name string) {
 	var pc [8]uintptr
 	n := runtime.Callers(3, pc[:])
 	if n <= 0 {
@@ -189,7 +186,7 @@ func (s Savepoint) Release(errp *error) {
 		if s.c.GetAutocommit() { // There is nothing to commit.
 			return
 		}
-		*errp = s.c.Exec(fmt.Sprintf("RELEASE %q;", s.name))
+		*errp = s.c.Exec("RELEASE " + s.name)
 		if *errp == nil {
 			return
 		}
@@ -201,10 +198,8 @@ func (s Savepoint) Release(errp *error) {
 		return
 	}
 	// ROLLBACK and RELEASE even if interrupted.
-	err := s.c.txnExecInterrupted(fmt.Sprintf(`
-		ROLLBACK TO %[1]q;
-		RELEASE %[1]q;
-	`, s.name))
+	err := s.c.txnExecInterrupted("ROLLBACK TO " +
+		s.name + "; RELEASE " + s.name)
 	if err != nil {
 		panic(err)
 	}
@@ -217,7 +212,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(fmt.Sprintf("ROLLBACK TO %q;", s.name))
+	return s.c.txnExecInterrupted("ROLLBACK TO " + s.name)
 }
 
 func (c *Conn) txnExecInterrupted(sql string) error {

util/osutil/open_windows.go

@@ -15,7 +15,7 @@ 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, uint32(perm.Perm()))
+	r, e := syscallOpen(name, flag|O_CLOEXEC, uint32(perm.Perm()))
 	if e != nil {
 		return nil, &os.PathError{Op: "open", Path: name, Err: e}
 	}

util/vtabutil/arg.go

@@ -26,6 +26,8 @@ func Unquote(val string) string {
 		return val
 	case '"':
 		old, new = `""`, `"`
+	case '`':
+		old, new = "``", "`"
 	case '\'':
 		old, new = `''`, `'`
 	}

vfs/README.md

@@ -46,7 +46,7 @@ to check if your build supports file locking.
 
 ### Write-Ahead Logging
 
-On 64-bit Unix, this module uses `mmap` to implement
+On 64-bit little-endian Unix, this module 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.
 

vfs/file.go

@@ -19,17 +19,18 @@ func (vfsOS) FullPathname(path string) (string, error) {
 	if err != nil {
 		return "", err
 	}
-	fi, err := os.Lstat(path)
+	return path, testSymlinks(filepath.Dir(path))
+}
+
+func testSymlinks(path string) error {
+	p, err := filepath.EvalSymlinks(path)
 	if err != nil {
-		if errors.Is(err, fs.ErrNotExist) {
-			return path, nil
-		}
-		return "", err
+		return err
 	}
-	if fi.Mode()&fs.ModeSymlink != 0 {
-		err = _OK_SYMLINK
+	if p != path {
+		return _OK_SYMLINK
 	}
-	return path, err
+	return nil
 }
 
 func (vfsOS) Delete(path string, syncDir bool) error {
@@ -74,7 +75,7 @@ func (vfsOS) Open(name string, flags OpenFlag) (File, OpenFlag, error) {
 }
 
 func (vfsOS) OpenFilename(name *Filename, flags OpenFlag) (File, OpenFlag, error) {
-	var oflags int
+	oflags := _O_NOFOLLOW
 	if flags&OPEN_EXCLUSIVE != 0 {
 		oflags |= os.O_EXCL
 	}

vfs/lock.go

@@ -75,20 +75,7 @@ func (f *vfsFile) Lock(lock LockLevel) error {
 		if f.lock <= LOCK_NONE || f.lock >= LOCK_EXCLUSIVE {
 			panic(util.AssertErr())
 		}
-		reserved := f.lock == LOCK_RESERVED
-		// A PENDING lock is needed before acquiring an EXCLUSIVE lock.
-		if f.lock < LOCK_PENDING {
-			// If we're already RESERVED, we can block indefinitely,
-			// since only new readers may briefly hold the PENDING lock.
-			if rc := osGetPendingLock(f.File, reserved /* block */); rc != _OK {
-				return rc
-			}
-			f.lock = LOCK_PENDING
-		}
-		// We already have PENDING, so we're just waiting for readers to leave.
-		// If we were RESERVED, we can wait for a little while, before invoking
-		// the busy handler; we will only do this once.
-		if rc := osGetExclusiveLock(f.File, reserved /* wait */); rc != _OK {
+		if rc := osGetExclusiveLock(f.File, &f.lock); rc != _OK {
 			return rc
 		}
 		f.lock = LOCK_EXCLUSIVE

vfs/memdb/api.go

@@ -43,7 +43,8 @@ func Create(name string, data []byte) {
 	}
 
 	// Convert data from WAL/2 to rollback journal.
-	if len(data) >= 20 && (data[18] == 2 && data[19] == 2 ||
+	if len(data) >= 20 && (false ||
+		data[18] == 2 && data[19] == 2 ||
 		data[18] == 3 && data[19] == 3) {
 		data[18] = 1
 		data[19] = 1

vfs/os_bsd.go

@@ -4,31 +4,15 @@ package vfs
 
 import (
 	"os"
-	"time"
 
 	"golang.org/x/sys/unix"
 )
 
-func osUnlock(file *os.File, start, len int64) _ErrorCode {
-	if start == 0 && len == 0 {
-		err := unix.Flock(int(file.Fd()), unix.LOCK_UN)
-		if err != nil {
-			return _IOERR_UNLOCK
-		}
-	}
-	return _OK
-}
-
-func osLock(file *os.File, how int, def _ErrorCode) _ErrorCode {
-	err := unix.Flock(int(file.Fd()), how)
-	return osLockErrorCode(err, def)
-}
-
-func osReadLock(file *os.File, _ /*start*/, _ /*len*/ int64, _ /*timeout*/ time.Duration) _ErrorCode {
+func osGetSharedLock(file *os.File) _ErrorCode {
 	return osLock(file, unix.LOCK_SH|unix.LOCK_NB, _IOERR_RDLOCK)
 }
 
-func osWriteLock(file *os.File, _ /*start*/, _ /*len*/ int64, _ /*timeout*/ time.Duration) _ErrorCode {
+func osGetReservedLock(file *os.File) _ErrorCode {
 	rc := osLock(file, unix.LOCK_EX|unix.LOCK_NB, _IOERR_LOCK)
 	if rc == _BUSY {
 		// The documentation states the lock is upgraded by releasing the previous lock,
@@ -38,3 +22,40 @@ func osWriteLock(file *os.File, _ /*start*/, _ /*len*/ int64, _ /*timeout*/ time
 	}
 	return rc
 }
+
+func osGetExclusiveLock(file *os.File, state *LockLevel) _ErrorCode {
+	if *state >= LOCK_RESERVED {
+		return _OK
+	}
+	return osGetReservedLock(file)
+}
+
+func osDowngradeLock(file *os.File, _ LockLevel) _ErrorCode {
+	rc := osLock(file, unix.LOCK_SH|unix.LOCK_NB, _IOERR_RDLOCK)
+	if rc == _BUSY {
+		// The documentation states the lock is upgraded by releasing the previous lock,
+		// then acquiring the new lock.
+		// This is a race, so return IOERR_RDLOCK to ensure the transaction is aborted.
+		return _IOERR_RDLOCK
+	}
+	return _OK
+}
+
+func osReleaseLock(file *os.File, _ LockLevel) _ErrorCode {
+	err := unix.Flock(int(file.Fd()), unix.LOCK_UN)
+	if err != nil {
+		return _IOERR_UNLOCK
+	}
+	return _OK
+}
+
+func osCheckReservedLock(file *os.File) (bool, _ErrorCode) {
+	// Test the RESERVED lock.
+	lock, rc := osTestLock(file, _RESERVED_BYTE, 1)
+	return lock == unix.F_WRLCK, rc
+}
+
+func osLock(file *os.File, how int, def _ErrorCode) _ErrorCode {
+	err := unix.Flock(int(file.Fd()), how)
+	return osLockErrorCode(err, def)
+}

vfs/os_f2fs_linux.go

@@ -1,4 +1,4 @@
-//go:build (amd64 || arm64 || riscv64) && !sqlite3_nosys
+//go:build (amd64 || arm64 || riscv64 || ppc64le) && !sqlite3_nosys
 
 package vfs
 
@@ -9,6 +9,7 @@ import (
 )
 
 const (
+	// https://godbolt.org/z/1PcK5vea3
 	_F2FS_IOC_START_ATOMIC_WRITE  = 62721
 	_F2FS_IOC_COMMIT_ATOMIC_WRITE = 62722
 	_F2FS_IOC_ABORT_ATOMIC_WRITE  = 62725

vfs/os_linux.go

@@ -53,10 +53,11 @@ func osLock(file *os.File, typ int16, start, len int64, timeout time.Duration, d
 			if errno, _ := err.(unix.Errno); errno != unix.EAGAIN {
 				break
 			}
-			if timeout < time.Since(before) {
+			if time.Since(before) > timeout {
 				break
 			}
-			time.Sleep(time.Duration(rand.Int63n(int64(time.Millisecond))))
+			const sleepIncrement = 1024*1024 - 1 // power of two, ~1ms
+			time.Sleep(time.Duration(rand.Int63() & sleepIncrement))
 		}
 	}
 	return osLockErrorCode(err, def)