Automatically load extensions. (#115)

Bumps [golang.org/x/crypto](https://github.com/golang/crypto) from 0.24.0 to 0.25.0.
- [Commits](https://github.com/golang/crypto/compare/v0.24.0...v0.25.0)

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

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

.github/workflows/repro.sh

@@ -18,6 +18,13 @@ mkdir -p tools/
 [ -d "tools/binaryen-version"* ] || curl -#L "$BINARYEN" | tar xzC tools &
 wait
 
-sqlite3/download.sh   # Download SQLite
-embed/build.sh        # Build Wasm
-git diff --exit-code  # Check diffs
+# Download and build SQLite
+sqlite3/download.sh
+embed/build.sh
+
+# Download and build sqlite-createtable-parser
+util/vtabutil/parse/download.sh
+util/vtabutil/parse/build.sh
+
+# Check diffs
+git diff --exit-code 

.github/workflows/repro.yml

@@ -3,6 +3,11 @@ name: Reproducible build
 on:
   workflow_dispatch:
 
+permissions:
+  contents: read
+  id-token: write
+  attestations: write
+
 jobs:
   build:
     strategy:
@@ -17,3 +22,10 @@ jobs:
 
     - name: Build
       run: .github/workflows/repro.sh
+
+    - uses: actions/attest-build-provenance@v1
+      if: matrix.os == 'ubuntu-latest'
+      with:
+        subject-path: |
+          embed/sqlite3.wasm
+          util/vtabutil/parse/sql3parse_table.wasm

.github/workflows/test.yml

@@ -83,6 +83,18 @@ jobs:
       run: go test -v ./...
 
   test-bsd:
+    strategy:
+      matrix:
+        os:
+          - name: freebsd
+            version: '14.0'
+            flags: '-test.v'
+          - name: openbsd
+            version: '7.5'
+            flags: '-test.v -test.short'
+          - name: netbsd
+            version: '10.0'
+            flags: '-test.v -test.short'
     runs-on: ubuntu-latest
     needs: test
 
@@ -96,15 +108,15 @@ jobs:
 
     - name: Build
       env:
-        GOOS: freebsd
-        TESTFLAGS: '-test.v'
+        GOOS: ${{ matrix.os.name }}
+        TESTFLAGS: ${{ matrix.os.flags }}
       run: .github/workflows/build-test.sh
 
     - name: Test
       uses: cross-platform-actions/action@v0.24.0
       with:
-        operating_system: freebsd
-        version: '14.0'
+        operating_system: ${{ matrix.os.name }}
+        version: ${{ matrix.os.version }}
         shell: bash
         run: . ./test.sh
         sync_files: runner-to-vm

README.md

@@ -33,6 +33,8 @@ Go, wazero and [`x/sys`](https://pkg.go.dev/golang.org/x/sys) are the _only_ run
   provides the [`array`](https://sqlite.org/carray.html) table-valued function.
 - [`github.com/ncruces/go-sqlite3/ext/blobio`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/blobio)
   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/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)
@@ -43,20 +45,24 @@ Go, wazero and [`x/sys`](https://pkg.go.dev/golang.org/x/sys) are the _only_ run
   reads data [line-by-line](https://github.com/asg017/sqlite-lines).
 - [`github.com/ncruces/go-sqlite3/ext/pivot`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/pivot)
   creates [pivot tables](https://github.com/jakethaw/pivot_vtab).
+- [`github.com/ncruces/go-sqlite3/ext/regexp`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/regexp)
+  provides regular expression functions.
 - [`github.com/ncruces/go-sqlite3/ext/statement`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/statement)
   creates [parameterized views](https://github.com/0x09/sqlite-statement-vtab).
 - [`github.com/ncruces/go-sqlite3/ext/stats`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/stats)
   provides [statistics](https://www.oreilly.com/library/view/sql-in-a/9780596155322/ch04s02.html) functions.
 - [`github.com/ncruces/go-sqlite3/ext/unicode`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/unicode)
   provides [Unicode aware](https://sqlite.org/src/dir/ext/icu) functions.
+- [`github.com/ncruces/go-sqlite3/ext/uuid`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/uuid)
+  generates [UUIDs](https://en.wikipedia.org/wiki/Universally_unique_identifier).
 - [`github.com/ncruces/go-sqlite3/ext/zorder`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/zorder)
   maps multidimensional data to one dimension.
+- [`github.com/ncruces/go-sqlite3/vfs/adiantum`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/adiantum)
+  wraps a VFS to offer encryption at rest.
 - [`github.com/ncruces/go-sqlite3/vfs/memdb`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/memdb)
   implements an in-memory VFS.
 - [`github.com/ncruces/go-sqlite3/vfs/readervfs`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/readervfs)
   implements a VFS for immutable databases.
-- [`github.com/ncruces/go-sqlite3/vfs/adiantum`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/adiantum)
-  wraps a VFS to offer encryption at rest.
 
 ### Advanced features
 
@@ -89,7 +95,8 @@ It also benefits greatly from [SQLite's](https://sqlite.org/testing.html) and
 
 Every commit is [tested](.github/workflows/test.yml) on
 Linux (amd64/arm64/386/riscv64/s390x), macOS (amd64/arm64),
-Windows (amd64), FreeBSD (amd64), illumos (amd64), and Solaris (amd64).
+Windows (amd64), FreeBSD (amd64), OpenBSD (amd64), NetBSD (amd64),
+illumos (amd64), and Solaris (amd64).
 
 The Go VFS is tested by running SQLite's
 [mptest](https://github.com/sqlite/sqlite/blob/master/mptest/mptest.c).

conn.go

@@ -72,6 +72,9 @@ func newConn(filename string, flags OpenFlag) (conn *Conn, err error) {
 	c.arena = c.newArena(1024)
 	c.ctx = context.WithValue(c.ctx, connKey{}, c)
 	c.handle, err = c.openDB(filename, flags)
+	if err == nil {
+		err = initExtensions(c)
+	}
 	if err != nil {
 		return nil, err
 	}

driver/driver.go

@@ -229,6 +229,7 @@ func (c *conn) Raw() *sqlite3.Conn {
 	return c.Conn
 }
 
+// Deprecated: use BeginTx instead.
 func (c *conn) Begin() (driver.Tx, error) {
 	return c.BeginTx(context.Background(), driver.TxOptions{})
 }
@@ -301,7 +302,7 @@ func (c *conn) PrepareContext(ctx context.Context, query string) (driver.Stmt, e
 		s.Close()
 		return nil, util.TailErr
 	}
-	return &stmt{Stmt: s, tmRead: c.tmRead, tmWrite: c.tmWrite}, nil
+	return &stmt{Stmt: s, tmRead: c.tmRead, tmWrite: c.tmWrite, inputs: -2}, nil
 }
 
 func (c *conn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {
@@ -335,6 +336,7 @@ type stmt struct {
 	*sqlite3.Stmt
 	tmWrite sqlite3.TimeFormat
 	tmRead  sqlite3.TimeFormat
+	inputs  int
 }
 
 var (
@@ -345,12 +347,17 @@ var (
 )
 
 func (s *stmt) NumInput() int {
+	if s.inputs >= -1 {
+		return s.inputs
+	}
 	n := s.Stmt.BindCount()
 	for i := 1; i <= n; i++ {
 		if s.Stmt.BindName(i) != "" {
+			s.inputs = -1
 			return -1
 		}
 	}
+	s.inputs = n
 	return n
 }
 
@@ -389,12 +396,7 @@ func (s *stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driv
 	return &rows{ctx: ctx, stmt: s}, nil
 }
 
-func (s *stmt) setupBindings(args []driver.NamedValue) error {
-	err := s.Stmt.ClearBindings()
-	if err != nil {
-		return err
-	}
-
+func (s *stmt) setupBindings(args []driver.NamedValue) (err error) {
 	var ids [3]int
 	for _, arg := range args {
 		ids := ids[:0]
@@ -558,19 +560,20 @@ func (r *rows) Next(dest []driver.Value) error {
 	return err
 }
 
-func (r *rows) decodeTime(i int, v any) (_ time.Time, _ bool) {
+func (r *rows) decodeTime(i int, v any) (_ time.Time, ok bool) {
 	if r.tmRead == sqlite3.TimeFormatDefault {
-		return
-	}
-	switch r.declType(i) {
-	case "DATE", "TIME", "DATETIME", "TIMESTAMP":
-		// maybe
-	default:
+		// handled by maybeTime
 		return
 	}
 	switch v.(type) {
 	case int64, float64, string:
-		// maybe
+		// could be a time value
+	default:
+		return
+	}
+	switch r.declType(i) {
+	case "DATE", "TIME", "DATETIME", "TIMESTAMP":
+		// could be a time value
 	default:
 		return
 	}

embed/README.md

@@ -24,4 +24,7 @@ See the [configuration options](../sqlite3/sqlite_cfg.h),
 and [patches](../sqlite3) applied.
 
 Built using [`wasi-sdk`](https://github.com/WebAssembly/wasi-sdk),
-and [`binaryen`](https://github.com/WebAssembly/binaryen).
+and [`binaryen`](https://github.com/WebAssembly/binaryen).
+
+The build is easily reproducible, and verifiable, using
+[Artifact Attestations](https://github.com/ncruces/go-sqlite3/attestations).

embed/build.sh

@@ -7,7 +7,7 @@ ROOT=../
 BINARYEN="$ROOT/tools/binaryen-version_117/bin"
 WASI_SDK="$ROOT/tools/wasi-sdk-22.0/bin"
 
-"$WASI_SDK/clang" --target=wasm32-wasi -std=c17 -flto -g0 -O2 \
+"$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -flto -g0 -O2 \
 	-Wall -Wextra -Wno-unused-parameter -Wno-unused-function \
 	-o sqlite3.wasm "$ROOT/sqlite3/main.c" \
 	-I"$ROOT/sqlite3" \

ext/array/array.go

@@ -15,8 +15,8 @@ import (
 // The argument must be bound to a Go slice or array of
 // ints, floats, bools, strings or byte slices,
 // using [sqlite3.BindPointer] or [sqlite3.Pointer].
-func Register(db *sqlite3.Conn) {
-	sqlite3.CreateModule[array](db, "array", nil,
+func Register(db *sqlite3.Conn) error {
+	return sqlite3.CreateModule(db, "array", nil,
 		func(db *sqlite3.Conn, _, _, _ string, _ ...string) (array, error) {
 			err := db.DeclareVTab(`CREATE TABLE x(value, array HIDDEN)`)
 			return array{}, err

ext/array/array_test.go

@@ -15,10 +15,7 @@ import (
 )
 
 func Example_driver() {
-	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
-		array.Register(c)
-		return nil
-	})
+	db, err := driver.Open(":memory:", array.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -53,14 +50,14 @@ func Example_driver() {
 }
 
 func Example() {
+	sqlite3.AutoExtension(array.Register)
+
 	db, err := sqlite3.Open(":memory:")
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer db.Close()
 
-	array.Register(db)
-
 	stmt, _, err := db.Prepare(`
 		SELECT name
 		FROM pragma_function_list
@@ -91,10 +88,7 @@ func Example() {
 func Test_cursor_Column(t *testing.T) {
 	t.Parallel()
 
-	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
-		array.Register(c)
-		return nil
-	})
+	db, err := driver.Open(":memory:", array.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -139,7 +133,10 @@ func Test_array_errors(t *testing.T) {
 	}
 	defer db.Close()
 
-	array.Register(db)
+	err = array.Register(db)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	err = db.Exec(`SELECT * FROM array()`)
 	if err == nil {

ext/blobio/blob.go

@@ -29,10 +29,11 @@ import (
 // along with the [sqlite3.Blob] handle.
 //
 // https://sqlite.org/c3ref/blob.html
-func Register(db *sqlite3.Conn) {
-	db.CreateFunction("readblob", 6, 0, readblob)
-	db.CreateFunction("writeblob", 6, 0, writeblob)
-	db.CreateFunction("openblob", -1, 0, openblob)
+func Register(db *sqlite3.Conn) error {
+	return errors.Join(
+		db.CreateFunction("readblob", 6, 0, readblob),
+		db.CreateFunction("writeblob", 6, 0, writeblob),
+		db.CreateFunction("openblob", -1, 0, openblob))
 }
 
 // OpenCallback is the type for the openblob callback.

ext/blobio/blob_test.go

@@ -18,10 +18,7 @@ import (
 
 func Example() {
 	// Open the database, registering the extension.
-	db, err := driver.Open("file:/test.db?vfs=memdb", func(conn *sqlite3.Conn) error {
-		blobio.Register(conn)
-		return nil
-	})
+	db, err := driver.Open("file:/test.db?vfs=memdb", blobio.Register)
 
 	if err != nil {
 		log.Fatal(err)
@@ -60,6 +57,11 @@ func Example() {
 	// Hello BLOB!
 }
 
+func init() {
+	sqlite3.AutoExtension(blobio.Register)
+	sqlite3.AutoExtension(array.Register)
+}
+
 func Test_readblob(t *testing.T) {
 	t.Parallel()
 
@@ -69,9 +71,6 @@ func Test_readblob(t *testing.T) {
 	}
 	defer db.Close()
 
-	blobio.Register(db)
-	array.Register(db)
-
 	err = db.Exec(`SELECT readblob()`)
 	if err == nil {
 		t.Fatal("want error")
@@ -129,9 +128,6 @@ func Test_openblob(t *testing.T) {
 	}
 	defer db.Close()
 
-	blobio.Register(db)
-	array.Register(db)
-
 	err = db.Exec(`SELECT openblob()`)
 	if err == nil {
 		t.Fatal("want error")

ext/bloom/bloom.go

@@ -0,0 +1,340 @@
+// Package bloom provides a Bloom filter virtual table.
+//
+// A Bloom filter is a space-efficient probabilistic data structure
+// used to test whether an element is a member of a set.
+//
+// https://github.com/nalgeon/sqlean/issues/27#issuecomment-1002267134
+package bloom
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"strconv"
+
+	"github.com/dchest/siphash"
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
+)
+
+// Register registers the bloom_filter virtual table:
+//
+//	CREATE VIRTUAL TABLE foo USING bloom_filter(nElements, falseProb, kHashes)
+func Register(db *sqlite3.Conn) error {
+	return sqlite3.CreateModule(db, "bloom_filter", create, connect)
+}
+
+type bloom struct {
+	db      *sqlite3.Conn
+	schema  string
+	storage string
+	prob    float64
+	bytes   int64
+	hashes  int
+}
+
+func create(db *sqlite3.Conn, _, schema, table string, arg ...string) (_ *bloom, err error) {
+	t := bloom{
+		db:      db,
+		schema:  schema,
+		storage: table + "_storage",
+	}
+
+	var nelem int64
+	if len(arg) > 0 {
+		nelem, err = strconv.ParseInt(arg[0], 10, 64)
+		if err != nil {
+			return nil, err
+		}
+		if nelem <= 0 {
+			return nil, util.ErrorString("bloom: number of elements in filter must be positive")
+		}
+	} else {
+		nelem = 100
+	}
+
+	if len(arg) > 1 {
+		t.prob, err = strconv.ParseFloat(arg[1], 64)
+		if err != nil {
+			return nil, err
+		}
+		if t.prob <= 0 || t.prob >= 1 {
+			return nil, util.ErrorString("bloom: probability must be in the range (0,1)")
+		}
+	} else {
+		t.prob = 0.01
+	}
+
+	if len(arg) > 2 {
+		t.hashes, err = strconv.Atoi(arg[2])
+		if err != nil {
+			return nil, err
+		}
+		if t.hashes <= 0 {
+			return nil, util.ErrorString("bloom: number of hash functions must be positive")
+		}
+	} else {
+		t.hashes = max(1, numHashes(t.prob))
+	}
+
+	t.bytes = numBytes(nelem, t.prob)
+
+	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)))
+	if err != nil {
+		return nil, err
+	}
+
+	id := db.LastInsertRowID()
+	defer db.SetLastInsertRowID(id)
+
+	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))
+	if err != nil {
+		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
+}
+
+func connect(db *sqlite3.Conn, _, schema, table string, arg ...string) (_ *bloom, err error) {
+	t := bloom{
+		db:      db,
+		schema:  schema,
+		storage: table + "_storage",
+	}
+
+	err = db.DeclareVTab(
+		`CREATE TABLE x(present, word HIDDEN NOT NULL PRIMARY KEY) WITHOUT ROWID`)
+	if err != nil {
+		return nil, err
+	}
+
+	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)))
+	if err != nil {
+		return nil, err
+	}
+	defer load.Close()
+
+	if !load.Step() {
+		if err = load.Err(); err == nil {
+			err = sqlite3.CORRUPT_VTAB
+		}
+		return nil, err
+	}
+
+	t.bytes = load.ColumnInt64(0)
+	t.prob = load.ColumnFloat(1)
+	t.hashes = load.ColumnInt(2)
+	return &t, nil
+}
+
+func (b *bloom) Destroy() error {
+	return b.db.Exec(fmt.Sprintf(`DROP TABLE %s.%s`,
+		sqlite3.QuoteIdentifier(b.schema),
+		sqlite3.QuoteIdentifier(b.storage)))
+}
+
+func (b *bloom) Rename(new string) error {
+	new += "_storage"
+	err := b.db.Exec(fmt.Sprintf(`ALTER TABLE %s.%s RENAME TO %s`,
+		sqlite3.QuoteIdentifier(b.schema),
+		sqlite3.QuoteIdentifier(b.storage),
+		sqlite3.QuoteIdentifier(new),
+	))
+	if err == nil {
+		b.storage = new
+	}
+	return err
+}
+
+func (t *bloom) ShadowTables() {}
+
+func (t *bloom) Integrity(schema, table string, flags int) error {
+	load, _, err := t.db.Prepare(fmt.Sprintf(
+		`SELECT typeof(data), length(data), p, n, m, k FROM %s.%s WHERE rowid = 1`,
+		sqlite3.QuoteIdentifier(t.schema), sqlite3.QuoteIdentifier(t.storage)))
+	if err != nil {
+		return fmt.Errorf("bloom: %v", err) // can't wrap!
+	}
+	defer load.Close()
+
+	err = util.ErrorString("bloom: invalid parameters")
+	if !load.Step() {
+		return err
+	}
+	if t := load.ColumnText(0); t != "blob" {
+		return err
+	}
+	if m := load.ColumnInt64(4); m <= 0 || m%8 != 0 {
+		return err
+	} else if load.ColumnInt64(1) != m/8 {
+		return err
+	}
+	if p := load.ColumnFloat(2); p <= 0 || p >= 1 {
+		return err
+	}
+	if n := load.ColumnInt64(3); n <= 0 {
+		return err
+	}
+	if k := load.ColumnInt(5); k <= 0 {
+		return err
+	}
+	return nil
+}
+
+func (b *bloom) BestIndex(idx *sqlite3.IndexInfo) error {
+	for n, cst := range idx.Constraint {
+		if cst.Usable && cst.Column == 1 &&
+			cst.Op == sqlite3.INDEX_CONSTRAINT_EQ {
+			idx.ConstraintUsage[n].ArgvIndex = 1
+			idx.OrderByConsumed = true
+			idx.EstimatedRows = 1
+			idx.EstimatedCost = float64(b.hashes)
+			idx.IdxFlags = sqlite3.INDEX_SCAN_UNIQUE
+			return nil
+		}
+	}
+	return sqlite3.CONSTRAINT
+}
+
+func (b *bloom) Update(arg ...sqlite3.Value) (rowid int64, err error) {
+	if arg[0].Type() != sqlite3.NULL {
+		if len(arg) == 1 {
+			return 0, util.ErrorString("bloom: elements cannot be deleted")
+		}
+		return 0, util.ErrorString("bloom: elements cannot be updated")
+	}
+
+	blob := arg[2].RawBlob()
+
+	f, err := b.db.OpenBlob(b.schema, b.storage, "data", 1, true)
+	if err != nil {
+		return 0, err
+	}
+	defer f.Close()
+
+	for n := 0; n < b.hashes; n++ {
+		hash := calcHash(n, blob)
+		hash %= uint64(b.bytes * 8)
+		bitpos := byte(hash % 8)
+		bytepos := int64(hash / 8)
+
+		var buf [1]byte
+		_, err = f.Seek(bytepos, io.SeekStart)
+		if err != nil {
+			return 0, err
+		}
+		_, err = f.Read(buf[:])
+		if err != nil {
+			return 0, err
+		}
+
+		buf[0] |= 1 << bitpos
+
+		_, err = f.Seek(bytepos, io.SeekStart)
+		if err != nil {
+			return 0, err
+		}
+		_, err = f.Write(buf[:])
+		if err != nil {
+			return 0, err
+		}
+	}
+	return 0, nil
+}
+
+func (b *bloom) Open() (sqlite3.VTabCursor, error) {
+	return &cursor{bloom: b}, nil
+}
+
+type cursor struct {
+	*bloom
+	arg *sqlite3.Value
+	eof bool
+}
+
+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()
+
+	f, err := c.db.OpenBlob(c.schema, c.storage, "data", 1, false)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	for n := 0; n < c.hashes && !c.eof; n++ {
+		hash := calcHash(n, blob)
+		hash %= uint64(c.bytes * 8)
+		bitpos := byte(hash % 8)
+		bytepos := int64(hash / 8)
+
+		var buf [1]byte
+		_, err = f.Seek(bytepos, io.SeekStart)
+		if err != nil {
+			return err
+		}
+		_, err = f.Read(buf[:])
+		if err != nil {
+			return err
+		}
+
+		c.eof = buf[0]&(1<<bitpos) == 0
+	}
+	return nil
+}
+
+func (c *cursor) Column(ctx *sqlite3.Context, n int) error {
+	switch n {
+	case 0:
+		ctx.ResultBool(true)
+	case 1:
+		ctx.ResultValue(*c.arg)
+	}
+	return nil
+}
+
+func (c *cursor) Next() error {
+	c.eof = true
+	return nil
+}
+
+func (c *cursor) EOF() bool {
+	return c.eof
+}
+
+func (c *cursor) RowID() (int64, error) {
+	return 0, nil
+}
+
+func calcHash(k int, b []byte) uint64 {
+	return siphash.Hash(^uint64(k), uint64(k), b)
+}
+
+func numHashes(p float64) int {
+	k := math.Round(-math.Log2(p))
+	return max(1, int(k))
+}
+
+func numBytes(n int64, p float64) int64 {
+	m := math.Ceil(float64(n) * math.Log(p) / -(math.Ln2 * math.Ln2))
+	return (int64(m) + 7) / 8
+}

ext/bloom/bloom_test.go

@@ -0,0 +1,140 @@
+package bloom_test
+
+import (
+	_ "embed"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+	_ "github.com/ncruces/go-sqlite3/embed"
+	"github.com/ncruces/go-sqlite3/ext/bloom"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+)
+
+func init() {
+	sqlite3.AutoExtension(bloom.Register)
+}
+
+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 VIRTUAL TABLE sports_cars USING bloom_filter(20);
+		INSERT INTO sports_cars VALUES ('ferrari'), ('lamborghini'), ('alfa romeo')
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	query, _, err := db.Prepare(`SELECT COUNT(*) FROM sports_cars(?)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = query.BindText(1, "ferrari")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !query.Step() {
+		t.Error("no rows")
+	}
+	if !query.ColumnBool(0) {
+		t.Error("want true")
+	}
+	err = query.Reset()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = query.BindText(1, "bmw")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !query.Step() {
+		t.Error("no rows")
+	}
+	if query.ColumnBool(0) {
+		t.Error("want false")
+	}
+	err = query.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`DROP TABLE sports_cars`)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+//go:embed testdata/bloom.db
+var testDB []byte
+
+func Test_compatible(t *testing.T) {
+	t.Parallel()
+
+	tmp := filepath.Join(t.TempDir(), "bloom.db")
+	err := os.WriteFile(tmp, testDB, 0666)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	db, err := sqlite3.Open("file:" + filepath.ToSlash(tmp) + "?nolock=1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	query, _, err := db.Prepare(`SELECT COUNT(*) FROM plants(?)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer query.Close()
+
+	err = query.BindText(1, "apple")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !query.Step() {
+		t.Error("no rows")
+	}
+	if !query.ColumnBool(0) {
+		t.Error("want true")
+	}
+	err = query.Reset()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = query.BindText(1, "lemon")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !query.Step() {
+		t.Error("no rows")
+	}
+	if query.ColumnBool(0) {
+		t.Error("want false")
+	}
+	err = query.Reset()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`PRAGMA integrity_check`)
+	if err != nil {
+		t.Error(err)
+	}
+
+	err = db.Exec(`PRAGMA quick_check`)
+	if err != nil {
+		t.Error(err)
+	}
+}

ext/csv/arg_test.go

@@ -40,6 +40,8 @@ func Test_uintArg(t *testing.T) {
 }
 
 func Test_boolArg(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		arg string
 		key string
@@ -76,6 +78,8 @@ func Test_boolArg(t *testing.T) {
 }
 
 func Test_runeArg(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		arg string
 		key string

ext/csv/csv.go

@@ -12,22 +12,24 @@ import (
 	"fmt"
 	"io"
 	"io/fs"
+	"strconv"
 	"strings"
 
 	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
 	"github.com/ncruces/go-sqlite3/util/osutil"
 	"github.com/ncruces/go-sqlite3/util/vtabutil"
 )
 
 // Register registers the CSV virtual table.
 // If a filename is specified, [os.Open] is used to open the file.
-func Register(db *sqlite3.Conn) {
-	RegisterFS(db, osutil.FS{})
+func Register(db *sqlite3.Conn) error {
+	return RegisterFS(db, osutil.FS{})
 }
 
 // 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) {
+func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
 	declare := func(db *sqlite3.Conn, _, _, _ string, arg ...string) (_ *table, err error) {
 		var (
 			filename string
@@ -36,6 +38,7 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) {
 			header   bool
 			columns  int  = -1
 			comma    rune = ','
+			comment  rune
 
 			done = map[string]struct{}{}
 		)
@@ -58,6 +61,8 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) {
 				columns, err = uintArg(key, val)
 			case "comma":
 				comma, err = runeArg(key, val)
+			case "comment":
+				comment, err = runeArg(key, val)
 			default:
 				return nil, fmt.Errorf("csv: unknown %q parameter", key)
 			}
@@ -68,15 +73,16 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) {
 		}
 
 		if (filename == "") == (data == "") {
-			return nil, fmt.Errorf(`csv: must specify either "filename" or "data" but not both`)
+			return nil, util.ErrorString(`csv: must specify either "filename" or "data" but not both`)
 		}
 
 		table := &table{
-			fsys:   fsys,
-			name:   filename,
-			data:   data,
-			comma:  comma,
-			header: header,
+			fsys:    fsys,
+			name:    filename,
+			data:    data,
+			comma:   comma,
+			comment: comment,
+			header:  header,
 		}
 
 		if schema == "" {
@@ -93,6 +99,12 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) {
 				}
 			}
 			schema = getSchema(header, columns, row)
+		} else {
+			defer func() {
+				if err == nil {
+					table.typs, err = getColumnAffinities(schema)
+				}
+			}()
 		}
 
 		err = db.DeclareVTab(schema)
@@ -106,15 +118,17 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) {
 		return table, nil
 	}
 
-	sqlite3.CreateModule(db, "csv", declare, declare)
+	return sqlite3.CreateModule(db, "csv", declare, declare)
 }
 
 type table struct {
-	fsys   fs.FS
-	name   string
-	data   string
-	comma  rune
-	header bool
+	fsys    fs.FS
+	name    string
+	data    string
+	typs    []affinity
+	comma   rune
+	comment rune
+	header  bool
 }
 
 func (t *table) BestIndex(idx *sqlite3.IndexInfo) error {
@@ -171,6 +185,7 @@ func (t *table) newReader() (*csv.Reader, io.Closer, error) {
 	csv := csv.NewReader(r)
 	csv.ReuseRecord = true
 	csv.Comma = t.comma
+	csv.Comment = t.comment
 	return csv, c, nil
 }
 
@@ -226,7 +241,36 @@ func (c *cursor) RowID() (int64, error) {
 
 func (c *cursor) Column(ctx *sqlite3.Context, col int) error {
 	if col < len(c.row) {
-		ctx.ResultText(c.row[col])
+		typ := text
+		if col < len(c.table.typs) {
+			typ = c.table.typs[col]
+		}
+
+		txt := c.row[col]
+		if txt == "" && typ != text {
+			return nil
+		}
+
+		switch typ {
+		case numeric, integer:
+			if strings.TrimLeft(txt, "+-0123456789") == "" {
+				if i, err := strconv.ParseInt(txt, 10, 64); err == nil {
+					ctx.ResultInt64(i)
+					return nil
+				}
+			}
+			fallthrough
+		case real:
+			if strings.TrimLeft(txt, "+-.0123456789Ee") == "" {
+				if f, err := strconv.ParseFloat(txt, 64); err == nil {
+					ctx.ResultFloat(f)
+					return nil
+				}
+			}
+			fallthrough
+		default:
+		}
+		ctx.ResultText(txt)
 	}
 	return nil
 }

ext/csv/csv_test.go

@@ -18,7 +18,10 @@ func Example() {
 	}
 	defer db.Close()
 
-	csv.Register(db)
+	err = csv.Register(db)
+	if err != nil {
+		log.Fatal(err)
+	}
 
 	err = db.Exec(`
 		CREATE VIRTUAL TABLE eurofxref USING csv(
@@ -51,6 +54,10 @@ func Example() {
 	// On Twosday, 1€ = $1.1342
 }
 
+func init() {
+	sqlite3.AutoExtension(csv.Register)
+}
+
 func TestRegister(t *testing.T) {
 	t.Parallel()
 
@@ -60,17 +67,17 @@ func TestRegister(t *testing.T) {
 	}
 	defer db.Close()
 
-	csv.Register(db)
-
 	const data = `
+# Comment
 "Rob"	"Pike"	rob
 "Ken"	Thompson	ken
 Robert	"Griesemer"	"gri"`
 	err = db.Exec(`
 		CREATE VIRTUAL TABLE temp.users USING csv(
-			data   = ` + sqlite3.Quote(data) + `,
-			schema = 'CREATE TABLE x(first_name, last_name, username)',
-			comma  = '\t'
+			data    = ` + sqlite3.Quote(data) + `,
+			schema  = 'CREATE TABLE x(first_name, last_name, username)',
+			comma   = '\t',
+			comment = '#'
 		)`)
 	if err != nil {
 		t.Fatal(err)
@@ -113,7 +120,7 @@ Robert	"Griesemer"	"gri"`
 	}
 }
 
-func TestRegister_errors(t *testing.T) {
+func TestAffinity(t *testing.T) {
 	t.Parallel()
 
 	db, err := sqlite3.Open(":memory:")
@@ -122,7 +129,47 @@ func TestRegister_errors(t *testing.T) {
 	}
 	defer db.Close()
 
-	csv.Register(db)
+	const data = "01\n0.10\ne"
+	err = db.Exec(`
+		CREATE VIRTUAL TABLE temp.nums USING csv(
+			data   = ` + sqlite3.Quote(data) + `,
+			schema = 'CREATE TABLE x(a numeric)'
+		)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT * FROM temp.nums`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer stmt.Close()
+
+	if stmt.Step() {
+		if got := stmt.ColumnText(0); got != "1" {
+			t.Errorf("got %q want 1", got)
+		}
+	}
+	if stmt.Step() {
+		if got := stmt.ColumnText(0); got != "0.1" {
+			t.Errorf("got %q want 0.1", got)
+		}
+	}
+	if stmt.Step() {
+		if got := stmt.ColumnText(0); got != "e" {
+			t.Errorf("got %q want e", got)
+		}
+	}
+}
+
+func TestRegister_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 temp.users USING csv()`)
 	if err == nil {

ext/csv/types.go

@@ -0,0 +1,51 @@
+package csv
+
+import (
+	"strings"
+
+	"github.com/ncruces/go-sqlite3/util/vtabutil"
+)
+
+type affinity byte
+
+const (
+	blob    affinity = 0
+	text    affinity = 1
+	numeric affinity = 2
+	integer affinity = 3
+	real    affinity = 4
+)
+
+func getColumnAffinities(schema string) ([]affinity, error) {
+	tab, err := vtabutil.Parse(schema)
+	if err != nil {
+		return nil, err
+	}
+
+	types := make([]affinity, len(tab.Columns))
+	for i, col := range tab.Columns {
+		types[i] = getAffinity(col.Type)
+	}
+	return types, nil
+}
+
+func getAffinity(declType string) affinity {
+	// https://sqlite.org/datatype3.html#determination_of_column_affinity
+	if declType == "" {
+		return blob
+	}
+	name := strings.ToUpper(declType)
+	if strings.Contains(name, "INT") {
+		return integer
+	}
+	if strings.Contains(name, "CHAR") || strings.Contains(name, "CLOB") || strings.Contains(name, "TEXT") {
+		return text
+	}
+	if strings.Contains(name, "BLOB") {
+		return blob
+	}
+	if strings.Contains(name, "REAL") || strings.Contains(name, "FLOA") || strings.Contains(name, "DOUB") {
+		return real
+	}
+	return numeric
+}

ext/csv/types_test.go

@@ -0,0 +1,32 @@
+package csv
+
+import "testing"
+
+func Test_getAffinity(t *testing.T) {
+	tests := []struct {
+		decl string
+		want affinity
+	}{
+		{"", blob},
+		{"INTEGER", integer},
+		{"TINYINT", integer},
+		{"TEXT", text},
+		{"CHAR", text},
+		{"CLOB", text},
+		{"BLOB", blob},
+		{"REAL", real},
+		{"FLOAT", real},
+		{"DOUBLE", real},
+		{"NUMERIC", numeric},
+		{"DECIMAL", numeric},
+		{"BOOLEAN", numeric},
+		{"DATETIME", numeric},
+	}
+	for _, tt := range tests {
+		t.Run(tt.decl, func(t *testing.T) {
+			if got := getAffinity(tt.decl); got != tt.want {
+				t.Errorf("getAffinity() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

ext/fileio/fileio.go

@@ -14,24 +14,26 @@ import (
 
 // Register registers SQL functions readfile, writefile, lsmode,
 // and the table-valued function fsdir.
-func Register(db *sqlite3.Conn) {
-	RegisterFS(db, nil)
+func Register(db *sqlite3.Conn) error {
+	return RegisterFS(db, nil)
 }
 
 // Register registers SQL functions readfile, lsmode,
 // and the table-valued function fsdir;
 // fsys will be used to read files and list directories.
-func RegisterFS(db *sqlite3.Conn, fsys fs.FS) {
-	db.CreateFunction("lsmode", 1, sqlite3.DETERMINISTIC, lsmode)
-	db.CreateFunction("readfile", 1, sqlite3.DIRECTONLY, readfile(fsys))
+func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
+	var err error
 	if fsys == nil {
-		db.CreateFunction("writefile", -1, sqlite3.DIRECTONLY, writefile)
+		err = db.CreateFunction("writefile", -1, sqlite3.DIRECTONLY, writefile)
 	}
-	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)
-		return fsdir{fsys}, err
-	})
+	return errors.Join(err,
+		db.CreateFunction("readfile", 1, sqlite3.DIRECTONLY, readfile(fsys)),
+		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)
+			return fsdir{fsys}, err
+		}))
 }
 
 func lsmode(ctx sqlite3.Context, arg ...sqlite3.Value) {

ext/fileio/fileio_test.go

@@ -17,10 +17,7 @@ import (
 func Test_lsmode(t *testing.T) {
 	t.Parallel()
 
-	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
-		fileio.Register(c)
-		return nil
-	})
+	db, err := driver.Open(":memory:", fileio.Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/fileio/fsdir_test.go

@@ -68,7 +68,10 @@ func Test_fsdir_errors(t *testing.T) {
 	}
 	defer db.Close()
 
-	fileio.Register(db)
+	err = fileio.Register(db)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	err = db.Exec(`SELECT name FROM fsdir()`)
 	if err == nil {

ext/fileio/write_test.go

@@ -7,7 +7,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
@@ -16,10 +15,7 @@ import (
 func Test_writefile(t *testing.T) {
 	t.Parallel()
 
-	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
-		Register(c)
-		return nil
-	})
+	db, err := driver.Open(":memory:", Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/hash/hash.go

@@ -21,47 +21,60 @@ package hash
 
 import (
 	"crypto"
+	"errors"
 
 	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
 )
 
 // Register registers cryptographic hash functions for a database connection.
-func Register(db *sqlite3.Conn) {
+func Register(db *sqlite3.Conn) error {
 	flags := sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
 
+	var errs util.ErrorJoiner
 	if crypto.MD4.Available() {
-		db.CreateFunction("md4", 1, flags, md4Func)
+		errs.Join(
+			db.CreateFunction("md4", 1, flags, md4Func))
 	}
 	if crypto.MD5.Available() {
-		db.CreateFunction("md5", 1, flags, md5Func)
+		errs.Join(
+			db.CreateFunction("md5", 1, flags, md5Func))
 	}
 	if crypto.SHA1.Available() {
-		db.CreateFunction("sha1", 1, flags, sha1Func)
+		errs.Join(
+			db.CreateFunction("sha1", 1, flags, sha1Func))
 	}
 	if crypto.SHA3_512.Available() {
-		db.CreateFunction("sha3", 1, flags, sha3Func)
-		db.CreateFunction("sha3", 2, flags, sha3Func)
+		errs.Join(
+			db.CreateFunction("sha3", 1, flags, sha3Func),
+			db.CreateFunction("sha3", 2, flags, sha3Func))
 	}
 	if crypto.SHA256.Available() {
-		db.CreateFunction("sha224", 1, flags, sha224Func)
-		db.CreateFunction("sha256", 1, flags, sha256Func)
-		db.CreateFunction("sha256", 2, flags, sha256Func)
+		errs.Join(
+			db.CreateFunction("sha224", 1, flags, sha224Func),
+			db.CreateFunction("sha256", 1, flags, sha256Func),
+			db.CreateFunction("sha256", 2, flags, sha256Func))
 	}
 	if crypto.SHA512.Available() {
-		db.CreateFunction("sha384", 1, flags, sha384Func)
-		db.CreateFunction("sha512", 1, flags, sha512Func)
-		db.CreateFunction("sha512", 2, flags, sha512Func)
+		errs.Join(
+			db.CreateFunction("sha384", 1, flags, sha384Func),
+			db.CreateFunction("sha512", 1, flags, sha512Func),
+			db.CreateFunction("sha512", 2, flags, sha512Func))
 	}
 	if crypto.BLAKE2s_256.Available() {
-		db.CreateFunction("blake2s", 1, flags, blake2sFunc)
+		errs.Join(
+			db.CreateFunction("blake2s", 1, flags, blake2sFunc))
 	}
 	if crypto.BLAKE2b_512.Available() {
-		db.CreateFunction("blake2b", 1, flags, blake2bFunc)
-		db.CreateFunction("blake2b", 2, flags, blake2bFunc)
+		errs.Join(
+			db.CreateFunction("blake2b", 1, flags, blake2bFunc),
+			db.CreateFunction("blake2b", 2, flags, blake2bFunc))
 	}
 	if crypto.RIPEMD160.Available() {
-		db.CreateFunction("ripemd160", 1, flags, ripemd160Func)
+		errs.Join(
+			db.CreateFunction("ripemd160", 1, flags, ripemd160Func))
 	}
+	return errors.Join(errs...)
 }
 
 func md4Func(ctx sqlite3.Context, arg ...sqlite3.Value) {

ext/hash/hash_test.go

@@ -7,7 +7,6 @@ import (
 	_ "crypto/sha512"
 	"testing"
 
-	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
@@ -53,10 +52,7 @@ func TestRegister(t *testing.T) {
 		{"blake2b('', 256)", "0E5751C026E543B2E8AB2EB06099DAA1D1E5DF47778F7787FAAB45CDF12FE3A8"},
 	}
 
-	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
-		Register(c)
-		return nil
-	})
+	db, err := driver.Open(":memory:", Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/lines/lines.go

@@ -13,6 +13,7 @@ package lines
 import (
 	"bufio"
 	"bytes"
+	"errors"
 	"fmt"
 	"io"
 	"io/fs"
@@ -25,27 +26,28 @@ import (
 // The lines function reads from a database blob or text.
 // The lines_read function reads from a file or an [io.Reader].
 // If a filename is specified, [os.Open] is used to open the file.
-func Register(db *sqlite3.Conn) {
-	RegisterFS(db, osutil.FS{})
+func Register(db *sqlite3.Conn) error {
+	return RegisterFS(db, osutil.FS{})
 }
 
 // RegisterFS registers the lines and lines_read table-valued functions.
 // The lines function reads from a database blob or text.
 // The lines_read function reads from a file or an [io.Reader].
 // If a filename is specified, fsys is used to open the file.
-func RegisterFS(db *sqlite3.Conn, fsys fs.FS) {
-	sqlite3.CreateModule[lines](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)
-			return lines{}, err
-		})
-	sqlite3.CreateModule[lines](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)
-			return lines{fsys}, err
-		})
+func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
+	return errors.Join(
+		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)
+				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)
+				return lines{fsys}, err
+			}))
 }
 
 type lines struct {

ext/lines/lines_test.go

@@ -18,10 +18,7 @@ import (
 )
 
 func Example() {
-	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
-		lines.Register(c)
-		return nil
-	})
+	db, err := driver.Open(":memory:", lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -70,10 +67,7 @@ func Example() {
 func Test_lines(t *testing.T) {
 	t.Parallel()
 
-	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
-		lines.Register(c)
-		return nil
-	})
+	db, err := driver.Open(":memory:", lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -103,10 +97,7 @@ func Test_lines(t *testing.T) {
 func Test_lines_error(t *testing.T) {
 	t.Parallel()
 
-	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
-		lines.Register(c)
-		return nil
-	})
+	db, err := driver.Open(":memory:", lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -130,10 +121,7 @@ func Test_lines_error(t *testing.T) {
 func Test_lines_read(t *testing.T) {
 	t.Parallel()
 
-	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
-		lines.Register(c)
-		return nil
-	})
+	db, err := driver.Open(":memory:", lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -164,10 +152,7 @@ func Test_lines_read(t *testing.T) {
 func Test_lines_test(t *testing.T) {
 	t.Parallel()
 
-	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
-		lines.Register(c)
-		return nil
-	})
+	db, err := driver.Open(":memory:", lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}

ext/pivot/pivot.go

@@ -9,11 +9,12 @@ import (
 	"strings"
 
 	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
 )
 
 // Register registers the pivot virtual table.
-func Register(db *sqlite3.Conn) {
-	sqlite3.CreateModule(db, "pivot", declare, declare)
+func Register(db *sqlite3.Conn) error {
+	return sqlite3.CreateModule(db, "pivot", declare, declare)
 }
 
 type table struct {
@@ -65,7 +66,7 @@ func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (_ *table, err err
 	}
 
 	if stmt.ColumnCount() != 2 {
-		return nil, fmt.Errorf("pivot: column definition query expects 2 result columns")
+		return nil, util.ErrorString("pivot: column definition query expects 2 result columns")
 	}
 	for stmt.Step() {
 		name := sqlite3.QuoteIdentifier(stmt.ColumnText(1))
@@ -83,7 +84,7 @@ func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (_ *table, err err
 	}
 
 	if stmt.ColumnCount() != 1 {
-		return nil, fmt.Errorf("pivot: cell query expects 1 result columns")
+		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)

ext/pivot/pivot_test.go

@@ -14,14 +14,14 @@ import (
 
 // https://antonz.org/sqlite-pivot-table/
 func Example() {
+	sqlite3.AutoExtension(pivot.Register)
+
 	db, err := sqlite3.Open(":memory:")
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer db.Close()
 
-	pivot.Register(db)
-
 	err = db.Exec(`
 		CREATE TABLE sales(product TEXT, year INT, income DECIMAL);
 		INSERT INTO  sales(product, year, income) VALUES
@@ -83,6 +83,10 @@ func Example() {
 	// gamma   80      75      78      80
 }
 
+func init() {
+	sqlite3.AutoExtension(pivot.Register)
+}
+
 func TestRegister(t *testing.T) {
 	t.Parallel()
 
@@ -92,8 +96,6 @@ func TestRegister(t *testing.T) {
 	}
 	defer db.Close()
 
-	pivot.Register(db)
-
 	err = db.Exec(`
 		CREATE TABLE r AS
 			SELECT 1 id UNION SELECT 2 UNION SELECT 3;
@@ -153,8 +155,6 @@ func TestRegister_errors(t *testing.T) {
 	}
 	defer db.Close()
 
-	pivot.Register(db)
-
 	err = db.Exec(`CREATE VIRTUAL TABLE pivot USING pivot()`)
 	if err == nil {
 		t.Fatal("want error")

ext/regexp/regexp.go

@@ -0,0 +1,78 @@
+// Package regexp provides additional regular expression functions.
+//
+// It provides the following Unicode aware functions:
+//   - regexp_like(),
+//   - regexp_substr(),
+//   - regexp_replace(),
+//   - and a REGEXP operator.
+//
+// The implementation uses Go [regexp/syntax] for regular expressions.
+//
+// https://github.com/nalgeon/sqlean/blob/main/docs/regexp.md
+package regexp
+
+import (
+	"errors"
+	"regexp"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+// 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("regexp", 2, flags, regex),
+		db.CreateFunction("regexp_like", 2, flags, regexLike),
+		db.CreateFunction("regexp_substr", 2, flags, regexSubstr),
+		db.CreateFunction("regexp_replace", 3, flags, regexReplace))
+}
+
+func load(ctx sqlite3.Context, i int, expr string) (*regexp.Regexp, error) {
+	re, ok := ctx.GetAuxData(i).(*regexp.Regexp)
+	if !ok {
+		r, err := regexp.Compile(expr)
+		if err != nil {
+			return nil, err
+		}
+		re = r
+		ctx.SetAuxData(0, r)
+	}
+	return re, nil
+}
+
+func regex(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	re, err := load(ctx, 0, arg[0].Text())
+	if err != nil {
+		ctx.ResultError(err)
+	} else {
+		ctx.ResultBool(re.Match(arg[1].RawText()))
+	}
+}
+
+func regexLike(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	re, err := load(ctx, 1, arg[1].Text())
+	if err != nil {
+		ctx.ResultError(err)
+	} else {
+		ctx.ResultBool(re.Match(arg[0].RawText()))
+	}
+}
+
+func regexSubstr(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	re, err := load(ctx, 1, arg[1].Text())
+	if err != nil {
+		ctx.ResultError(err)
+	} else {
+		ctx.ResultRawText(re.Find(arg[0].RawText()))
+	}
+}
+
+func regexReplace(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	re, err := load(ctx, 1, arg[1].Text())
+	if err != nil {
+		ctx.ResultError(err)
+	} else {
+		ctx.ResultRawText(re.ReplaceAll(arg[0].RawText(), arg[2].RawText()))
+	}
+}

ext/regexp/regexp_test.go

@@ -0,0 +1,68 @@
+package regexp
+
+import (
+	"testing"
+
+	"github.com/ncruces/go-sqlite3/driver"
+	_ "github.com/ncruces/go-sqlite3/embed"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+)
+
+func TestRegister(t *testing.T) {
+	t.Parallel()
+
+	db, err := driver.Open(":memory:", Register)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	tests := []struct {
+		test string
+		want string
+	}{
+		{`'Hello' REGEXP 'elo'`, "0"},
+		{`'Hello' REGEXP 'ell'`, "1"},
+		{`'Hello' REGEXP 'el.'`, "1"},
+		{`regexp_like('Hello', 'elo')`, "0"},
+		{`regexp_like('Hello', 'ell')`, "1"},
+		{`regexp_like('Hello', 'el.')`, "1"},
+		{`regexp_substr('Hello', 'el.')`, "ell"},
+		{`regexp_replace('Hello', 'llo', 'll')`, "Hell"},
+	}
+
+	for _, tt := range tests {
+		var got string
+		err := db.QueryRow(`SELECT ` + tt.test).Scan(&got)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got != tt.want {
+			t.Errorf("got %q, want %q", got, tt.want)
+		}
+	}
+}
+
+func TestRegister_errors(t *testing.T) {
+	t.Parallel()
+
+	db, err := driver.Open(":memory:", Register)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	tests := []string{
+		`'' REGEXP ?`,
+		`regexp_like('', ?)`,
+		`regexp_substr('', ?)`,
+		`regexp_replace('', ?, '')`,
+	}
+
+	for _, tt := range tests {
+		err := db.QueryRow(`SELECT `+tt, `\`).Scan(nil)
+		if err == nil {
+			t.Fatal("want error")
+		}
+	}
+}

ext/statement/stmt.go

@@ -8,17 +8,17 @@ package statement
 
 import (
 	"encoding/json"
-	"fmt"
 	"strconv"
 	"strings"
 	"unsafe"
 
 	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
 )
 
 // Register registers the statement virtual table.
-func Register(db *sqlite3.Conn) {
-	sqlite3.CreateModule(db, "statement", declare, declare)
+func Register(db *sqlite3.Conn) error {
+	return sqlite3.CreateModule(db, "statement", declare, declare)
 }
 
 type table struct {
@@ -29,7 +29,7 @@ type table struct {
 
 func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (*table, error) {
 	if len(arg) != 1 {
-		return nil, fmt.Errorf("statement: wrong number of arguments")
+		return nil, util.ErrorString("statement: wrong number of arguments")
 	}
 
 	sql := "SELECT * FROM\n" + arg[0]

ext/statement/stmt_test.go

@@ -12,14 +12,14 @@ import (
 )
 
 func Example() {
+	sqlite3.AutoExtension(statement.Register)
+
 	db, err := sqlite3.Open(":memory:")
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer db.Close()
 
-	statement.Register(db)
-
 	err = db.Exec(`
 		CREATE VIRTUAL TABLE split_date USING statement((
 			SELECT
@@ -48,6 +48,10 @@ func Example() {
 	// Twosday was 2022-2-22
 }
 
+func init() {
+	sqlite3.AutoExtension(statement.Register)
+}
+
 func TestRegister(t *testing.T) {
 	t.Parallel()
 
@@ -57,8 +61,6 @@ func TestRegister(t *testing.T) {
 	}
 	defer db.Close()
 
-	statement.Register(db)
-
 	err = db.Exec(`
 		CREATE VIRTUAL TABLE arguments USING statement((SELECT ? AS a, ? AS b, ? AS c))
 	`)
@@ -107,8 +109,6 @@ func TestRegister_errors(t *testing.T) {
 	}
 	defer db.Close()
 
-	statement.Register(db)
-
 	err = db.Exec(`CREATE VIRTUAL TABLE split_date USING statement()`)
 	if err == nil {
 		t.Fatal("want error")

ext/stats/boolean_test.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	"github.com/ncruces/go-sqlite3/ext/stats"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
@@ -18,8 +17,6 @@ func TestRegister_boolean(t *testing.T) {
 	}
 	defer db.Close()
 
-	stats.Register(db)
-
 	err = db.Exec(`CREATE TABLE data (x)`)
 	if err != nil {
 		t.Fatal(err)

ext/stats/percentile_test.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	"github.com/ncruces/go-sqlite3/ext/stats"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
@@ -19,8 +18,6 @@ func TestRegister_percentile(t *testing.T) {
 	}
 	defer db.Close()
 
-	stats.Register(db)
-
 	err = db.Exec(`CREATE TABLE data (x)`)
 	if err != nil {
 		t.Fatal(err)

ext/stats/stats.go

@@ -44,33 +44,38 @@
 // [ANSI SQL Aggregate Functions]: https://www.oreilly.com/library/view/sql-in-a/9780596155322/ch04s02.html
 package stats
 
-import "github.com/ncruces/go-sqlite3"
+import (
+	"errors"
+
+	"github.com/ncruces/go-sqlite3"
+)
 
 // Register registers statistics functions.
-func Register(db *sqlite3.Conn) {
+func Register(db *sqlite3.Conn) error {
 	flags := sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
-	db.CreateWindowFunction("var_pop", 1, flags, newVariance(var_pop))
-	db.CreateWindowFunction("var_samp", 1, flags, newVariance(var_samp))
-	db.CreateWindowFunction("stddev_pop", 1, flags, newVariance(stddev_pop))
-	db.CreateWindowFunction("stddev_samp", 1, flags, newVariance(stddev_samp))
-	db.CreateWindowFunction("covar_pop", 2, flags, newCovariance(var_pop))
-	db.CreateWindowFunction("covar_samp", 2, flags, newCovariance(var_samp))
-	db.CreateWindowFunction("corr", 2, flags, newCovariance(corr))
-	db.CreateWindowFunction("regr_r2", 2, flags, newCovariance(regr_r2))
-	db.CreateWindowFunction("regr_sxx", 2, flags, newCovariance(regr_sxx))
-	db.CreateWindowFunction("regr_syy", 2, flags, newCovariance(regr_syy))
-	db.CreateWindowFunction("regr_sxy", 2, flags, newCovariance(regr_sxy))
-	db.CreateWindowFunction("regr_avgx", 2, flags, newCovariance(regr_avgx))
-	db.CreateWindowFunction("regr_avgy", 2, flags, newCovariance(regr_avgy))
-	db.CreateWindowFunction("regr_slope", 2, flags, newCovariance(regr_slope))
-	db.CreateWindowFunction("regr_intercept", 2, flags, newCovariance(regr_intercept))
-	db.CreateWindowFunction("regr_count", 2, flags, newCovariance(regr_count))
-	db.CreateWindowFunction("regr_json", 2, flags, newCovariance(regr_json))
-	db.CreateWindowFunction("median", 1, flags, newPercentile(median))
-	db.CreateWindowFunction("percentile_cont", 2, flags, newPercentile(percentile_cont))
-	db.CreateWindowFunction("percentile_disc", 2, flags, newPercentile(percentile_disc))
-	db.CreateWindowFunction("every", 1, flags, newBoolean(every))
-	db.CreateWindowFunction("some", 1, flags, newBoolean(some))
+	return errors.Join(
+		db.CreateWindowFunction("var_pop", 1, flags, newVariance(var_pop)),
+		db.CreateWindowFunction("var_samp", 1, flags, newVariance(var_samp)),
+		db.CreateWindowFunction("stddev_pop", 1, flags, newVariance(stddev_pop)),
+		db.CreateWindowFunction("stddev_samp", 1, flags, newVariance(stddev_samp)),
+		db.CreateWindowFunction("covar_pop", 2, flags, newCovariance(var_pop)),
+		db.CreateWindowFunction("covar_samp", 2, flags, newCovariance(var_samp)),
+		db.CreateWindowFunction("corr", 2, flags, newCovariance(corr)),
+		db.CreateWindowFunction("regr_r2", 2, flags, newCovariance(regr_r2)),
+		db.CreateWindowFunction("regr_sxx", 2, flags, newCovariance(regr_sxx)),
+		db.CreateWindowFunction("regr_syy", 2, flags, newCovariance(regr_syy)),
+		db.CreateWindowFunction("regr_sxy", 2, flags, newCovariance(regr_sxy)),
+		db.CreateWindowFunction("regr_avgx", 2, flags, newCovariance(regr_avgx)),
+		db.CreateWindowFunction("regr_avgy", 2, flags, newCovariance(regr_avgy)),
+		db.CreateWindowFunction("regr_slope", 2, flags, newCovariance(regr_slope)),
+		db.CreateWindowFunction("regr_intercept", 2, flags, newCovariance(regr_intercept)),
+		db.CreateWindowFunction("regr_count", 2, flags, newCovariance(regr_count)),
+		db.CreateWindowFunction("regr_json", 2, flags, newCovariance(regr_json)),
+		db.CreateWindowFunction("median", 1, flags, newPercentile(median)),
+		db.CreateWindowFunction("percentile_cont", 2, flags, newPercentile(percentile_cont)),
+		db.CreateWindowFunction("percentile_disc", 2, flags, newPercentile(percentile_disc)),
+		db.CreateWindowFunction("every", 1, flags, newBoolean(every)),
+		db.CreateWindowFunction("some", 1, flags, newBoolean(some)))
 }
 
 const (

ext/stats/stats_test.go

@@ -10,6 +10,10 @@ import (
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
+func init() {
+	sqlite3.AutoExtension(stats.Register)
+}
+
 func TestRegister_variance(t *testing.T) {
 	t.Parallel()
 
@@ -19,8 +23,6 @@ func TestRegister_variance(t *testing.T) {
 	}
 	defer db.Close()
 
-	stats.Register(db)
-
 	err = db.Exec(`CREATE TABLE data (x)`)
 	if err != nil {
 		t.Fatal(err)
@@ -88,8 +90,6 @@ func TestRegister_covariance(t *testing.T) {
 	}
 	defer db.Close()
 
-	stats.Register(db)
-
 	err = db.Exec(`CREATE TABLE data (y, x)`)
 	if err != nil {
 		t.Fatal(err)
@@ -217,8 +217,6 @@ func Benchmark_variance(b *testing.B) {
 	}
 	defer db.Close()
 
-	stats.Register(db)
-
 	stmt, _, err := db.Prepare(`SELECT var_pop(value) FROM generate_series(0, ?)`)
 	if err != nil {
 		b.Fatal(err)

ext/unicode/unicode.go

@@ -18,6 +18,7 @@ package unicode
 
 import (
 	"bytes"
+	"errors"
 	"regexp"
 	"strings"
 	"unicode/utf8"
@@ -30,29 +31,29 @@ import (
 )
 
 // Register registers Unicode aware functions for a database connection.
-func Register(db *sqlite3.Conn) {
+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),
+		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("icu_load_collation", 2, sqlite3.DIRECTONLY,
+			func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+				name := arg[1].Text()
+				if name == "" {
+					return
+				}
 
-	db.CreateFunction("like", 2, flags, like)
-	db.CreateFunction("like", 3, flags, like)
-	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("icu_load_collation", 2, sqlite3.DIRECTONLY,
-		func(ctx sqlite3.Context, arg ...sqlite3.Value) {
-			name := arg[1].Text()
-			if name == "" {
-				return
-			}
-
-			err := RegisterCollation(db, arg[0].Text(), name)
-			if err != nil {
-				ctx.ResultError(err)
-				return
-			}
-		})
+				err := RegisterCollation(db, arg[0].Text(), name)
+				if err != nil {
+					ctx.ResultError(err)
+					return
+				}
+			}))
 }
 
 // RegisterCollation registers a Unicode collation sequence for a database connection.
@@ -111,7 +112,7 @@ func regex(ctx sqlite3.Context, arg ...sqlite3.Value) {
 			return
 		}
 		re = r
-		ctx.SetAuxData(0, re)
+		ctx.SetAuxData(0, r)
 	}
 	ctx.ResultBool(re.Match(arg[1].RawText()))
 }

ext/uuid/uuid.go

@@ -0,0 +1,168 @@
+// Package uuid provides functions to generate RFC 4122 UUIDs.
+//
+// https://sqlite.org/src/file/ext/misc/uuid.c
+package uuid
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+
+	"github.com/google/uuid"
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
+)
+
+// Register registers the SQL functions:
+//
+//	uuid([version], [domain/namespace], [id/data])
+//
+// Generates a UUID as a string.
+//
+//	uuid_str(u)
+//
+// Converts a UUID into a well-formed UUID string.
+//
+//	uuid_blob(u)
+//
+// Converts a UUID into a 16-byte blob.
+func Register(db *sqlite3.Conn) error {
+	flags := sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
+	return errors.Join(
+		db.CreateFunction("uuid", 0, sqlite3.INNOCUOUS, generate),
+		db.CreateFunction("uuid", 1, sqlite3.INNOCUOUS, generate),
+		db.CreateFunction("uuid", 2, sqlite3.INNOCUOUS, generate),
+		db.CreateFunction("uuid", 3, sqlite3.INNOCUOUS, generate),
+		db.CreateFunction("uuid_str", 1, flags, toString),
+		db.CreateFunction("uuid_blob", 1, flags, toBlob))
+}
+
+func generate(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	var (
+		ver int
+		err error
+		u   uuid.UUID
+	)
+
+	if len(arg) > 0 {
+		ver = arg[0].Int()
+	} else {
+		ver = 4
+	}
+
+	switch ver {
+	case 1:
+		u, err = uuid.NewUUID()
+	case 4:
+		u, err = uuid.NewRandom()
+	case 6:
+		u, err = uuid.NewV6()
+	case 7:
+		u, err = uuid.NewV7()
+
+	case 2:
+		var domain uuid.Domain
+		if len(arg) > 1 {
+			domain = uuid.Domain(arg[1].Int64())
+			if domain == 0 {
+				if txt := arg[1].RawText(); len(txt) > 0 {
+					switch txt[0] | 0x20 {
+					case 'g': // group
+						domain = 1
+					case 'o': // org
+						domain = 2
+					}
+				}
+			}
+		}
+		if len(arg) > 2 {
+			id := uint32(arg[2].Int64())
+			u, err = uuid.NewDCESecurity(domain, id)
+		} else if domain == uuid.Person {
+			u, err = uuid.NewDCEPerson()
+		} else if domain == uuid.Group {
+			u, err = uuid.NewDCEGroup()
+		} else {
+			err = util.ErrorString("missing id")
+		}
+
+	case 3, 5:
+		if len(arg) < 2 {
+			err = util.ErrorString("missing data")
+			break
+		}
+		ns, err := fromValue(arg[1])
+		if err != nil {
+			space := arg[1].RawText()
+			switch {
+			case bytes.EqualFold(space, []byte("url")):
+				ns = uuid.NameSpaceURL
+			case bytes.EqualFold(space, []byte("oid")):
+				ns = uuid.NameSpaceOID
+			case bytes.EqualFold(space, []byte("dns")):
+				ns = uuid.NameSpaceDNS
+			case bytes.EqualFold(space, []byte("fqdn")):
+				ns = uuid.NameSpaceDNS
+			case bytes.EqualFold(space, []byte("x500")):
+				ns = uuid.NameSpaceX500
+			default:
+				ctx.ResultError(err)
+				return
+			}
+		}
+		if ver == 3 {
+			u = uuid.NewMD5(ns, arg[2].RawBlob())
+		} else {
+			u = uuid.NewSHA1(ns, arg[2].RawBlob())
+		}
+
+	default:
+		err = fmt.Errorf("invalid version: %d", ver)
+	}
+
+	if err != nil {
+		ctx.ResultError(fmt.Errorf("uuid: %w", err))
+	} else {
+		ctx.ResultText(u.String())
+	}
+}
+
+func fromValue(arg sqlite3.Value) (u uuid.UUID, err error) {
+	switch t := arg.Type(); t {
+	case sqlite3.TEXT:
+		u, err = uuid.ParseBytes(arg.RawText())
+		if err != nil {
+			err = fmt.Errorf("uuid: %w", err)
+		}
+
+	case sqlite3.BLOB:
+		blob := arg.RawBlob()
+		if len := len(blob); len != 16 {
+			err = fmt.Errorf("uuid: invalid BLOB length: %d", len)
+		} else {
+			copy(u[:], blob)
+		}
+
+	default:
+		err = fmt.Errorf("uuid: invalid type: %v", t)
+	}
+	return u, err
+}
+
+func toBlob(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	u, err := fromValue(arg[0])
+	if err != nil {
+		ctx.ResultError(err)
+	} else {
+		ctx.ResultBlob(u[:])
+	}
+}
+
+func toString(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	u, err := fromValue(arg[0])
+	if err != nil {
+		ctx.ResultError(err)
+	} else {
+		ctx.ResultText(u.String())
+	}
+}

ext/uuid/uuid_test.go

@@ -0,0 +1,177 @@
+package uuid
+
+import (
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/ncruces/go-sqlite3/driver"
+	_ "github.com/ncruces/go-sqlite3/embed"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+)
+
+func Test_generate(t *testing.T) {
+	t.Parallel()
+
+	db, err := driver.Open(":memory:", Register)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	var u uuid.UUID
+
+	// Version 4, SQLite compatible
+	err = db.QueryRow(`SELECT uuid()`).Scan(&u)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := u.Version(); got != 4 {
+		t.Errorf("got %d, want 4", got)
+	}
+
+	// Invalid version
+	err = db.QueryRow(`SELECT uuid(8)`).Scan(&u)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	// Custom version, no arguments
+	for _, want := range []uuid.Version{1, 2, 4, 6, 7} {
+		err = db.QueryRow(`SELECT uuid(?)`, want).Scan(&u)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got := u.Version(); got != want {
+			t.Errorf("got %d, want %d", got, want)
+		}
+	}
+
+	// Version 2, custom arguments
+	err = db.QueryRow(`SELECT uuid(2, 4)`).Scan(&u)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	err = db.QueryRow(`SELECT uuid(2, 'group')`).Scan(&u)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := u.Version(); got != 2 {
+		t.Errorf("got %d, want 2", got)
+	}
+	if got := u.Domain(); got != uuid.Group {
+		t.Errorf("got %d, want 1", got)
+	}
+
+	dce := []struct {
+		out uuid.Domain
+		in  any
+		id  uint32
+	}{
+		{uuid.Person, "user", 42},
+		{uuid.Group, "group", 42},
+		{uuid.Org, "org", 42},
+		{uuid.Person, 0, 42},
+		{uuid.Group, 1, 42},
+		{uuid.Org, 2, 42},
+		{3, 3, 42},
+	}
+	for _, tt := range dce {
+		err = db.QueryRow(`SELECT uuid(2, ?, ?)`, tt.in, tt.id).Scan(&u)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got := u.Version(); got != 2 {
+			t.Errorf("got %d, want 2", got)
+		}
+		if got := u.Domain(); got != tt.out {
+			t.Errorf("got %d, want %d", got, tt.out)
+		}
+		if got := u.ID(); got != tt.id {
+			t.Errorf("got %d, want %d", got, tt.id)
+		}
+	}
+
+	// Versions 3 and 5
+	err = db.QueryRow(`SELECT uuid(3)`).Scan(&u)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	err = db.QueryRow(`SELECT uuid(3, 0, '')`).Scan(&u)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	hash := []struct {
+		ver  uuid.Version
+		ns   any
+		data string
+		u    uuid.UUID
+	}{
+		{3, "oid", "2.999", uuid.MustParse("31cb1efa-18c4-3d19-89ba-df6a74ddbd1d")},
+		{3, "dns", "www.example.com", uuid.MustParse("5df41881-3aed-3515-88a7-2f4a814cf09e")},
+		{3, "fqdn", "www.example.com", uuid.MustParse("5df41881-3aed-3515-88a7-2f4a814cf09e")},
+		{3, "url", "https://www.example.com/", uuid.MustParse("7fed185f-0864-319f-875b-a3d5458e30ac")},
+		{3, "x500", "CN=Test User 1, O=Example Organization, ST=California, C=US", uuid.MustParse("addf5e97-9287-3834-abfd-7edcbe7db56f")},
+		{3, "url", "https://www.php.net", uuid.MustParse("3f703955-aaba-3e70-a3cb-baff6aa3b28f")},
+		{5, "url", "https://www.php.net", uuid.MustParse("a8f6ae40-d8a7-58f0-be05-a22f94eca9ec")},
+	}
+	for _, tt := range hash {
+		err = db.QueryRow(`SELECT uuid(?, ?, ?)`, tt.ver, tt.ns, tt.data).Scan(&u)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if u != tt.u {
+			t.Errorf("got %v, want %v", u, tt.u)
+		}
+	}
+}
+
+func Test_convert(t *testing.T) {
+	t.Parallel()
+
+	db, err := driver.Open(":memory:", Register)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	var u uuid.UUID
+	lits := []string{
+		"'6ba7b8119dad11d180b400c04fd430c8'",
+		"'6ba7b811-9dad-11d1-80b4-00c04fd430c8'",
+		"'{6ba7b811-9dad-11d1-80b4-00c04fd430c8}'",
+		"X'6ba7b8119dad11d180b400c04fd430c8'",
+	}
+
+	for _, tt := range lits {
+		err = db.QueryRow(`SELECT uuid_str(` + tt + `)`).Scan(&u)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if u != uuid.NameSpaceURL {
+			t.Errorf("got %v, want %v", u, uuid.NameSpaceURL)
+		}
+	}
+
+	for _, tt := range lits {
+		err = db.QueryRow(`SELECT uuid_blob(` + tt + `)`).Scan(&u)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if u != uuid.NameSpaceURL {
+			t.Errorf("got %v, want %v", u, uuid.NameSpaceURL)
+		}
+	}
+
+	err = db.QueryRow(`SELECT uuid_str(X'cafe')`).Scan(&u)
+	if err == nil {
+		t.Fatal("want error")
+	}
+
+	err = db.QueryRow(`SELECT uuid_blob(X'cafe')`).Scan(&u)
+	if err == nil {
+		t.Fatal("want error")
+	}
+}

ext/zorder/zorder.go

@@ -4,15 +4,18 @@
 package zorder
 
 import (
+	"errors"
+
 	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/internal/util"
 )
 
 // Register registers the zorder and unzorder SQL functions.
-func Register(db *sqlite3.Conn) {
+func Register(db *sqlite3.Conn) error {
 	flags := sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
-	db.CreateFunction("zorder", -1, flags, zorder)
-	db.CreateFunction("unzorder", 3, flags, unzorder)
+	return errors.Join(
+		db.CreateFunction("zorder", -1, flags, zorder),
+		db.CreateFunction("unzorder", 3, flags, unzorder))
 }
 
 func zorder(ctx sqlite3.Context, arg ...sqlite3.Value) {

ext/zorder/zorder_test.go

@@ -3,7 +3,6 @@ package zorder_test
 import (
 	"testing"
 
-	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	"github.com/ncruces/go-sqlite3/ext/zorder"
@@ -13,10 +12,7 @@ import (
 func TestRegister_zorder(t *testing.T) {
 	t.Parallel()
 
-	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
-		zorder.Register(c)
-		return nil
-	})
+	db, err := driver.Open(":memory:", zorder.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -60,10 +56,7 @@ func TestRegister_zorder(t *testing.T) {
 func TestRegister_unzorder(t *testing.T) {
 	t.Parallel()
 
-	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
-		zorder.Register(c)
-		return nil
-	})
+	db, err := driver.Open(":memory:", zorder.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -90,10 +83,7 @@ func TestRegister_unzorder(t *testing.T) {
 func TestRegister_error(t *testing.T) {
 	t.Parallel()
 
-	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
-		zorder.Register(c)
-		return nil
-	})
+	db, err := driver.Open(":memory:", zorder.Register)
 	if err != nil {
 		t.Fatal(err)
 	}

func.go

@@ -31,8 +31,9 @@ func (c *Conn) CollationNeeded(cb func(db *Conn, name string)) error {
 //
 // This can be used to load schemas that contain
 // one or more unknown collating sequences.
-func (c *Conn) AnyCollationNeeded() {
-	c.call("sqlite3_anycollseq_init", uint64(c.handle), 0, 0)
+func (c Conn) AnyCollationNeeded() error {
+	r := c.call("sqlite3_anycollseq_init", uint64(c.handle), 0, 0)
+	return c.error(r)
 }
 
 // CreateCollation defines a new collating sequence.

func_test.go

@@ -130,8 +130,8 @@ func ExampleContext_SetAuxData() {
 				ctx.ResultError(err)
 				return
 			}
-			ctx.SetAuxData(0, r)
 			re = r
+			ctx.SetAuxData(0, r)
 		}
 		ctx.ResultBool(re.Match(arg[1].RawText()))
 	})

go.mod

@@ -2,16 +2,21 @@ module github.com/ncruces/go-sqlite3
 
 go 1.21
 
+toolchain go1.22.5
+
 require (
+	github.com/dchest/siphash v1.2.3
 	github.com/ncruces/julianday v1.0.0
 	github.com/ncruces/sort v0.1.2
 	github.com/psanford/httpreadat v0.1.0
 	github.com/tetratelabs/wazero v1.7.3
-	golang.org/x/crypto v0.24.0
+	golang.org/x/crypto v0.25.0
 	golang.org/x/sync v0.7.0
-	golang.org/x/sys v0.21.0
+	golang.org/x/sys v0.22.0
 	golang.org/x/text v0.16.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

@@ -1,3 +1,7 @@
+github.com/dchest/siphash v1.2.3 h1:QXwFc8cFOR2dSa/gE6o/HokBMWtLUaNDVd+22aKHeEA=
+github.com/dchest/siphash v1.2.3/go.mod h1:0NvQU092bT0ipiFN++/rXm69QG9tVxLAlQHIXMPAkHc=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M=
 github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
 github.com/ncruces/sort v0.1.2 h1:zKQ9CA4fpHPF6xsUhRTfi5EEryspuBpe/QA4VWQOV1U=
@@ -6,12 +10,12 @@ github.com/psanford/httpreadat v0.1.0 h1:VleW1HS2zO7/4c7c7zNl33fO6oYACSagjJIyMIw
 github.com/psanford/httpreadat v0.1.0/go.mod h1:Zg7P+TlBm3bYbyHTKv/EdtSJZn3qwbPwpfZ/I9GKCRE=
 github.com/tetratelabs/wazero v1.7.3 h1:PBH5KVahrt3S2AHgEjKu4u+LlDbbk+nsGE3KLucy6Rw=
 github.com/tetratelabs/wazero v1.7.3/go.mod h1:ytl6Zuh20R/eROuyDaGPkp82O9C/DJfXAwJfQ3X6/7Y=
-golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
-golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
+golang.org/x/crypto v0.25.0 h1:ypSNr+bnYL2YhwoMt2zPxHFmbAN1KZs/njMG3hxUp30=
+golang.org/x/crypto v0.25.0/go.mod h1:T+wALwcMOSE0kXgUAnPAHqTLW+XHgcELELW8VaDgm/M=
 golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
 golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
-golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
+golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
 golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
 lukechampine.com/adiantum v1.1.1 h1:4fp6gTxWCqpEbLy40ExiYDDED3oUNWx5cTqBCtPdZqA=

gormlite/download.sh

@@ -3,9 +3,11 @@ set -euo pipefail
 
 cd -P -- "$(dirname -- "$0")"
 
-curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.5/ddlmod.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.5/ddlmod_test.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.5/error_translator.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.5/migrator.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.5/sqlite.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.5/sqlite_test.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.6/ddlmod.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.6/ddlmod_test.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.6/error_translator.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.6/migrator.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.6/sqlite.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.6/sqlite_test.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.6/sqlite_test.go"
+curl -#L "https://github.com/glebarez/sqlite/raw/v1.11.0/sqlite_error_translator_test.go" > error_translator_test.go

gormlite/error_translator_test.go

@@ -0,0 +1,48 @@
+package gormlite
+
+import (
+	"testing"
+
+	"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{
+		Logger:         logger.Default.LogMode(logger.Silent),
+		TranslateError: true})
+
+	if err != nil {
+		t.Errorf("Expected Open to succeed; got error: %v", err)
+	}
+	if db == nil {
+		t.Errorf("Expected db to be non-nil.")
+	}
+
+	err = db.AutoMigrate(&Article{})
+	if err != nil {
+		t.Errorf("Expected to migrate database models to succeed: %v", err)
+	}
+
+	err = db.Create(&Article{ArticleNumber: "A00000XX"}).Error
+	if err != nil {
+		t.Errorf("Expected first create to succeed: %v", err)
+	}
+
+	err = db.Create(&Article{ArticleNumber: "A00000XX"}).Error
+	if err == nil {
+		t.Errorf("Expected second create to fail.")
+	}
+
+	if err != gorm.ErrDuplicatedKey {
+		t.Errorf("Expected error from second create to be gorm.ErrDuplicatedKey: %v", err)
+	}
+}

gormlite/go.mod

@@ -2,8 +2,10 @@ module github.com/ncruces/go-sqlite3/gormlite
 
 go 1.21
 
+toolchain go1.22.5
+
 require (
-	github.com/ncruces/go-sqlite3 v0.16.1
+	github.com/ncruces/go-sqlite3 v0.16.3
 	gorm.io/gorm v1.25.10
 )
 
@@ -12,5 +14,5 @@ require (
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/ncruces/julianday v1.0.0 // indirect
 	github.com/tetratelabs/wazero v1.7.3 // indirect
-	golang.org/x/sys v0.21.0 // indirect
+	golang.org/x/sys v0.22.0 // indirect
 )

gormlite/go.sum

@@ -2,14 +2,14 @@ github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
 github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
-github.com/ncruces/go-sqlite3 v0.16.1 h1:1wHv7s8y+fWK44UIliotJ42ZV41A5T0sjIAqGmnMrkc=
-github.com/ncruces/go-sqlite3 v0.16.1/go.mod h1:feFXbBcbLtxNk6XWG1ROt8MS9+E45yCW3G8o4ixIqZ8=
+github.com/ncruces/go-sqlite3 v0.16.3 h1:Ky0denOdmAGOoCE6lQlw6GCJNMD8gTikNWe8rpu+Gjc=
+github.com/ncruces/go-sqlite3 v0.16.3/go.mod h1:sAU/vQwBmZ2hq5BlW/KTzqRFizL43bv2JQoBLgXhcMI=
 github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M=
 github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
 github.com/tetratelabs/wazero v1.7.3 h1:PBH5KVahrt3S2AHgEjKu4u+LlDbbk+nsGE3KLucy6Rw=
 github.com/tetratelabs/wazero v1.7.3/go.mod h1:ytl6Zuh20R/eROuyDaGPkp82O9C/DJfXAwJfQ3X6/7Y=
-golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
-golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
+golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
 golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
 gorm.io/gorm v1.25.10 h1:dQpO+33KalOA+aFYGlK+EfxcI5MbO7EP2yYygwh9h+s=

internal/util/error.go

@@ -104,3 +104,13 @@ func ErrorCodeString(rc uint32) string {
 	}
 	return "sqlite3: unknown error"
 }
+
+type ErrorJoiner []error
+
+func (j *ErrorJoiner) Join(errs ...error) {
+	for _, err := range errs {
+		if err != nil {
+			*j = append(*j, err)
+		}
+	}
+}

internal/util/mmap.go

@@ -46,7 +46,7 @@ func (s *mmapState) new(ctx context.Context, mod api.Module, size int32) *Mapped
 	// Save the newly allocated region.
 	ptr := uint32(stack[0])
 	buf := View(mod, ptr, uint64(size))
-	addr := uintptr(unsafe.Pointer(&buf[0]))
+	addr := unsafe.Pointer(&buf[0])
 	s.regions = append(s.regions, &MappedRegion{
 		Ptr:  ptr,
 		addr: addr,
@@ -56,7 +56,7 @@ func (s *mmapState) new(ctx context.Context, mod api.Module, size int32) *Mapped
 }
 
 type MappedRegion struct {
-	addr uintptr
+	addr unsafe.Pointer
 	Ptr  uint32
 	size int32
 	used bool
@@ -76,23 +76,15 @@ func (r *MappedRegion) Unmap() error {
 	// We can't munmap the region, otherwise it could be remaped.
 	// Instead, convert it to a protected, private, anonymous mapping.
 	// If successful, it can be reused for a subsequent mmap.
-	_, err := mmap(r.addr, uintptr(r.size),
-		unix.PROT_NONE, unix.MAP_PRIVATE|unix.MAP_ANON|unix.MAP_FIXED,
-		-1, 0)
+	_, err := unix.MmapPtr(-1, 0, r.addr, uintptr(r.size),
+		unix.PROT_NONE, unix.MAP_PRIVATE|unix.MAP_FIXED|unix.MAP_ANON)
 	r.used = err != nil
 	return err
 }
 
 func (r *MappedRegion) mmap(f *os.File, offset int64, prot int) error {
-	_, err := mmap(r.addr, uintptr(r.size),
-		prot, unix.MAP_SHARED|unix.MAP_FIXED,
-		int(f.Fd()), offset)
+	_, err := unix.MmapPtr(int(f.Fd()), offset, r.addr, uintptr(r.size),
+		prot, unix.MAP_SHARED|unix.MAP_FIXED)
 	r.used = err == nil
 	return err
 }
-
-// We need the low level mmap for MAP_FIXED to work.
-// Bind the syscall version hoping that it is more stable.
-
-//go:linkname mmap syscall.mmap
-func mmap(addr, length uintptr, prot, flag, fd int, pos int64) (*byte, error)

registry.go

@@ -0,0 +1,30 @@
+package sqlite3
+
+import "sync"
+
+var (
+	// +checklocks:extRegistryMtx
+	extRegistry    []func(*Conn) error
+	extRegistryMtx sync.RWMutex
+)
+
+// AutoExtension causes the entryPoint function to be invoked
+// for each new database connection that is created.
+//
+// https://sqlite.org/c3ref/auto_extension.html
+func AutoExtension(entryPoint func(*Conn) error) {
+	extRegistryMtx.Lock()
+	defer extRegistryMtx.Unlock()
+	extRegistry = append(extRegistry, entryPoint)
+}
+
+func initExtensions(c *Conn) error {
+	extRegistryMtx.RLock()
+	defer extRegistryMtx.RUnlock()
+	for _, f := range extRegistry {
+		if err := f(c); err != nil {
+			return err
+		}
+	}
+	return nil
+}

sqlite3/download.sh

@@ -19,7 +19,6 @@ curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/ext/misc/ieee754.
 curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/ext/misc/regexp.c"
 curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/ext/misc/series.c"
 curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/ext/misc/uint.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.0/ext/misc/uuid.c"
 cd ~-
 
 cd ../vfs/tests/mptest/testdata/

sqlite3/main.c

@@ -8,7 +8,6 @@
 #include "ext/regexp.c"
 #include "ext/series.c"
 #include "ext/uint.c"
-#include "ext/uuid.c"
 // Bindings
 #include "column.c"
 #include "func.c"
@@ -28,6 +27,5 @@ __attribute__((constructor)) void init() {
   sqlite3_auto_extension((void (*)(void))sqlite3_regexp_init);
   sqlite3_auto_extension((void (*)(void))sqlite3_series_init);
   sqlite3_auto_extension((void (*)(void))sqlite3_uint_init);
-  sqlite3_auto_extension((void (*)(void))sqlite3_uuid_init);
   sqlite3_auto_extension((void (*)(void))sqlite3_time_init);
 }

sqlite3/vtab.c

@@ -1,16 +1,18 @@
+#include <stdbool.h>
 #include <stddef.h>
 
 #include "include.h"
 #include "sqlite3.h"
 
-#define SQLITE_VTAB_CREATOR_GO /******/ 0x01
-#define SQLITE_VTAB_DESTROYER_GO /****/ 0x02
-#define SQLITE_VTAB_UPDATER_GO /******/ 0x04
-#define SQLITE_VTAB_RENAMER_GO /******/ 0x08
-#define SQLITE_VTAB_OVERLOADER_GO /***/ 0x10
-#define SQLITE_VTAB_CHECKER_GO /******/ 0x20
-#define SQLITE_VTAB_TXN_GO /**********/ 0x40
-#define SQLITE_VTAB_SAVEPOINTER_GO /**/ 0x80
+#define SQLITE_VTAB_CREATOR_GO /******/ 0x001
+#define SQLITE_VTAB_DESTROYER_GO /****/ 0x002
+#define SQLITE_VTAB_UPDATER_GO /******/ 0x004
+#define SQLITE_VTAB_RENAMER_GO /******/ 0x008
+#define SQLITE_VTAB_OVERLOADER_GO /***/ 0x010
+#define SQLITE_VTAB_CHECKER_GO /******/ 0x020
+#define SQLITE_VTAB_TXN_GO /**********/ 0x040
+#define SQLITE_VTAB_SAVEPOINTER_GO /**/ 0x080
+#define SQLITE_VTAB_SHADOWTABS_GO /***/ 0x100
 
 int go_vtab_create(sqlite3_module *, int argc, const char *const *argv,
                    sqlite3_vtab **, char **pzErr);
@@ -157,6 +159,8 @@ static int go_vtab_integrity_wrapper(sqlite3_vtab *pVTab, const char *zSchema,
   return rc;
 }
 
+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) {
   struct go_module *mod = malloc(sizeof(struct go_module));
@@ -208,6 +212,9 @@ int sqlite3_create_module_go(sqlite3 *db, const char *zName, int flags,
     mod->base.xRelease = go_vtab_release;
     mod->base.xRollbackTo = go_vtab_rollback_to;
   }
+  if (flags & SQLITE_VTAB_SHADOWTABS_GO) {
+    mod->base.xShadowName = go_vtab_shadown_name_wrapper;
+  }
   if (mod->base.xCreate && !mod->base.xDestroy) {
     mod->base.xDestroy = mod->base.xDisconnect;
   }

tests/func_test.go

@@ -207,7 +207,10 @@ func TestAnyCollationNeeded(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	db.AnyCollationNeeded()
+	err = db.AnyCollationNeeded()
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	stmt, _, err := db.Prepare(`SELECT id, name FROM users ORDER BY name COLLATE silly`)
 	if err != nil {

tests/stmt_test.go

@@ -618,6 +618,9 @@ func TestStmt_ColumnTime(t *testing.T) {
 }
 
 func TestStmt_Error(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping in short mode")
+	}
 	if bits.UintSize < 64 {
 		t.Skip("skipping on 32-bit")
 	}

util/vtabutil/README.md

@@ -0,0 +1,8 @@
+# Virtual Table utility functions 
+
+This package implements utilities mostly useful to virtual table implementations.
+
+It also wraps a [parser](https://github.com/marcobambini/sqlite-createtable-parser)
+for the [`CREATE`](https://sqlite.org/lang_createtable.html) and
+[`ALTER TABLE`](https://sqlite.org/lang_altertable.html) commands,
+created by [Marco Bambini](https://github.com/marcobambini).

util/vtabutil/arg.go

@@ -1,4 +1,3 @@
-// Package ioutil implements virtual table utility functions.
 package vtabutil
 
 import "strings"

util/vtabutil/const.go

@@ -0,0 +1,61 @@
+package vtabutil
+
+const (
+	_NONE = iota
+	_MEMORY
+	_SYNTAX
+	_UNSUPPORTEDSQL
+)
+
+type ConflictClause uint32
+
+const (
+	CONFLICT_NONE ConflictClause = iota
+	CONFLICT_ROLLBACK
+	CONFLICT_ABORT
+	CONFLICT_FAIL
+	CONFLICT_IGNORE
+	CONFLICT_REPLACE
+)
+
+type OrderClause uint32
+
+const (
+	ORDER_NONE OrderClause = iota
+	ORDER_ASC
+	ORDER_DESC
+)
+
+type FKAction uint32
+
+const (
+	FKACTION_NONE FKAction = iota
+	FKACTION_SETNULL
+	FKACTION_SETDEFAULT
+	FKACTION_CASCADE
+	FKACTION_RESTRICT
+	FKACTION_NOACTION
+)
+
+type FKDefType uint32
+
+const (
+	DEFTYPE_NONE FKDefType = iota
+	DEFTYPE_DEFERRABLE
+	DEFTYPE_DEFERRABLE_INITIALLY_DEFERRED
+	DEFTYPE_DEFERRABLE_INITIALLY_IMMEDIATE
+	DEFTYPE_NOTDEFERRABLE
+	DEFTYPE_NOTDEFERRABLE_INITIALLY_DEFERRED
+	DEFTYPE_NOTDEFERRABLE_INITIALLY_IMMEDIATE
+)
+
+type StatementType uint32
+
+const (
+	CREATE_UNKNOWN StatementType = iota
+	CREATE_TABLE
+	ALTER_RENAME_TABLE
+	ALTER_RENAME_COLUMN
+	ALTER_ADD_COLUMN
+	ALTER_DROP_COLUMN
+)

util/vtabutil/parse.go

@@ -0,0 +1,209 @@
+package vtabutil
+
+import (
+	"context"
+	"sync"
+
+	_ "embed"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/tetratelabs/wazero"
+	"github.com/tetratelabs/wazero/api"
+)
+
+const (
+	errp = 4
+	sqlp = 8
+)
+
+var (
+	//go:embed parse/sql3parse_table.wasm
+	binary   []byte
+	once     sync.Once
+	runtime  wazero.Runtime
+	compiled wazero.CompiledModule
+)
+
+// Parse parses a [CREATE] or [ALTER TABLE] command.
+//
+// [CREATE]: https://sqlite.org/lang_createtable.html
+// [ALTER TABLE]: https://sqlite.org/lang_altertable.html
+func Parse(sql string) (_ *Table, err error) {
+	once.Do(func() {
+		ctx := context.Background()
+		cfg := wazero.NewRuntimeConfigInterpreter()
+		runtime = wazero.NewRuntimeWithConfig(ctx, cfg)
+		compiled, err = runtime.CompileModule(ctx, binary)
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	ctx := context.Background()
+	mod, err := runtime.InstantiateModule(ctx, compiled, wazero.NewModuleConfig().WithName(""))
+	if err != nil {
+		return nil, err
+	}
+	defer mod.Close(ctx)
+
+	if buf, ok := mod.Memory().Read(sqlp, uint32(len(sql))); ok {
+		copy(buf, sql)
+	}
+
+	r, err := mod.ExportedFunction("sql3parse_table").Call(ctx, sqlp, uint64(len(sql)), errp)
+	if err != nil {
+		return nil, err
+	}
+
+	c, _ := mod.Memory().ReadUint32Le(errp)
+	switch c {
+	case _MEMORY:
+		panic(util.OOMErr)
+	case _SYNTAX:
+		return nil, util.ErrorString("sql3parse: invalid syntax")
+	case _UNSUPPORTEDSQL:
+		return nil, util.ErrorString("sql3parse: unsupported SQL")
+	}
+
+	var tab Table
+	tab.load(mod, uint32(r[0]), sql)
+	return &tab, nil
+}
+
+// Table holds metadata about a table.
+type Table struct {
+	Name           string
+	Schema         string
+	Comment        string
+	IsTemporary    bool
+	IsIfNotExists  bool
+	IsWithoutRowID bool
+	IsStrict       bool
+	Columns        []Column
+	Type           StatementType
+	CurrentName    string
+	NewName        string
+}
+
+func (t *Table) load(mod api.Module, ptr uint32, sql string) {
+	t.Name = loadString(mod, ptr+0, sql)
+	t.Schema = loadString(mod, ptr+8, sql)
+	t.Comment = loadString(mod, ptr+16, sql)
+
+	t.IsTemporary = loadBool(mod, ptr+24)
+	t.IsIfNotExists = loadBool(mod, ptr+25)
+	t.IsWithoutRowID = loadBool(mod, ptr+26)
+	t.IsStrict = loadBool(mod, ptr+27)
+
+	t.Columns = loadSlice(mod, ptr+28, func(ptr uint32, res *Column) {
+		p, _ := mod.Memory().ReadUint32Le(ptr)
+		res.load(mod, p, sql)
+	})
+
+	t.Type = loadEnum[StatementType](mod, ptr+44)
+	t.CurrentName = loadString(mod, ptr+48, sql)
+	t.NewName = loadString(mod, ptr+56, sql)
+}
+
+// Column holds metadata about a column.
+type Column struct {
+	Name                  string
+	Type                  string
+	Length                string
+	ConstraintName        string
+	Comment               string
+	IsPrimaryKey          bool
+	IsAutoIncrement       bool
+	IsNotNull             bool
+	IsUnique              bool
+	PKOrder               OrderClause
+	PKConflictClause      ConflictClause
+	NotNullConflictClause ConflictClause
+	UniqueConflictClause  ConflictClause
+	CheckExpr             string
+	DefaultExpr           string
+	CollateName           string
+	ForeignKeyClause      *ForeignKey
+}
+
+func (c *Column) load(mod api.Module, ptr uint32, sql string) {
+	c.Name = loadString(mod, ptr+0, sql)
+	c.Type = loadString(mod, ptr+8, sql)
+	c.Length = loadString(mod, ptr+16, sql)
+	c.ConstraintName = loadString(mod, ptr+24, sql)
+	c.Comment = loadString(mod, ptr+32, sql)
+
+	c.IsPrimaryKey = loadBool(mod, ptr+40)
+	c.IsAutoIncrement = loadBool(mod, ptr+41)
+	c.IsNotNull = loadBool(mod, ptr+42)
+	c.IsUnique = loadBool(mod, ptr+43)
+
+	c.PKOrder = loadEnum[OrderClause](mod, ptr+44)
+	c.PKConflictClause = loadEnum[ConflictClause](mod, ptr+48)
+	c.NotNullConflictClause = loadEnum[ConflictClause](mod, ptr+52)
+	c.UniqueConflictClause = loadEnum[ConflictClause](mod, ptr+56)
+
+	c.CheckExpr = loadString(mod, ptr+60, sql)
+	c.DefaultExpr = loadString(mod, ptr+68, sql)
+	c.CollateName = loadString(mod, ptr+76, sql)
+
+	if ptr, _ := mod.Memory().ReadUint32Le(ptr + 84); ptr != 0 {
+		c.ForeignKeyClause = &ForeignKey{}
+		c.ForeignKeyClause.load(mod, ptr, sql)
+	}
+}
+
+type ForeignKey struct {
+	Table      string
+	Columns    []string
+	OnDelete   FKAction
+	OnUpdate   FKAction
+	Match      string
+	Deferrable FKDefType
+}
+
+func (f *ForeignKey) load(mod api.Module, ptr uint32, sql string) {
+	f.Table = loadString(mod, ptr+0, sql)
+
+	f.Columns = loadSlice(mod, ptr+8, func(ptr uint32, res *string) {
+		*res = loadString(mod, ptr, sql)
+	})
+
+	f.OnDelete = loadEnum[FKAction](mod, ptr+16)
+	f.OnUpdate = loadEnum[FKAction](mod, ptr+20)
+	f.Match = loadString(mod, ptr+24, sql)
+	f.Deferrable = loadEnum[FKDefType](mod, ptr+32)
+}
+
+func loadString(mod api.Module, ptr uint32, sql string) string {
+	off, _ := mod.Memory().ReadUint32Le(ptr + 0)
+	if off == 0 {
+		return ""
+	}
+	len, _ := mod.Memory().ReadUint32Le(ptr + 4)
+	return sql[off-sqlp : off+len-sqlp]
+}
+
+func loadSlice[T any](mod api.Module, ptr uint32, fn func(uint32, *T)) []T {
+	ref, _ := mod.Memory().ReadUint32Le(ptr + 4)
+	if ref == 0 {
+		return nil
+	}
+	len, _ := mod.Memory().ReadUint32Le(ptr + 0)
+	res := make([]T, len)
+	for i := range res {
+		fn(ref, &res[i])
+		ref += 4
+	}
+	return res
+}
+
+func loadEnum[T ~uint32](mod api.Module, ptr uint32) T {
+	val, _ := mod.Memory().ReadUint32Le(ptr)
+	return T(val)
+}
+
+func loadBool(mod api.Module, ptr uint32) bool {
+	val, _ := mod.Memory().ReadByte(ptr)
+	return val != 0
+}

util/vtabutil/parse/.gitignore

@@ -0,0 +1,2 @@
+sql3parse_table.c
+sql3parse_table.h

util/vtabutil/parse/build.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd -P -- "$(dirname -- "$0")"
+
+ROOT=../../../
+BINARYEN="$ROOT/tools/binaryen-version_117/bin"
+WASI_SDK="$ROOT/tools/wasi-sdk-22.0/bin"
+
+"$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -flto -g0 -Oz \
+	-Wall -Wextra -o sql3parse_table.wasm main.c \
+	-mexec-model=reactor \
+	-msimd128 -mmutable-globals -mmultivalue \
+	-mbulk-memory -mreference-types \
+	-mnontrapping-fptoint -msign-ext \
+	-fno-stack-protector -fno-stack-clash-protection \
+	-Wl,--stack-first \
+	-Wl,--import-undefined \
+	-Wl,--export=sql3parse_table
+
+trap 'rm -f sql3parse_table.tmp' EXIT
+"$BINARYEN/wasm-ctor-eval" -c _initialize sql3parse_table.wasm -o sql3parse_table.tmp
+"$BINARYEN/wasm-opt" --strip --strip-debug --strip-producers -c -Oz \
+	sql3parse_table.tmp -o sql3parse_table.wasm \
+	--enable-simd --enable-mutable-globals --enable-multivalue \
+	--enable-bulk-memory --enable-reference-types \
+	--enable-nontrapping-float-to-int --enable-sign-ext

util/vtabutil/parse/download.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd -P -- "$(dirname -- "$0")"
+
+curl -#OL "https://github.com/ncruces/sqlite-createtable-parser/raw/master/sql3parse_table.c"
+curl -#OL "https://github.com/ncruces/sqlite-createtable-parser/raw/master/sql3parse_table.h"

util/vtabutil/parse/main.c

@@ -0,0 +1,42 @@
+#include <stddef.h>
+
+#include "sql3parse_table.c"
+
+static_assert(offsetof(sql3table, name) == 0, "Unexpected offset");
+static_assert(offsetof(sql3table, schema) == 8, "Unexpected offset");
+static_assert(offsetof(sql3table, comment) == 16, "Unexpected offset");
+static_assert(offsetof(sql3table, is_temporary) == 24, "Unexpected offset");
+static_assert(offsetof(sql3table, is_ifnotexists) == 25, "Unexpected offset");
+static_assert(offsetof(sql3table, is_withoutrowid) == 26, "Unexpected offset");
+static_assert(offsetof(sql3table, is_strict) == 27, "Unexpected offset");
+static_assert(offsetof(sql3table, num_columns) == 28, "Unexpected offset");
+static_assert(offsetof(sql3table, columns) == 32, "Unexpected offset");
+static_assert(offsetof(sql3table, type) == 44, "Unexpected offset");
+static_assert(offsetof(sql3table, current_name) == 48, "Unexpected offset");
+static_assert(offsetof(sql3table, new_name) == 56, "Unexpected offset");
+
+static_assert(offsetof(sql3column, name) == 0, "Unexpected offset");
+static_assert(offsetof(sql3column, type) == 8, "Unexpected offset");
+static_assert(offsetof(sql3column, length) == 16, "Unexpected offset");
+static_assert(offsetof(sql3column, constraint_name) == 24, "Unexpected offset");
+static_assert(offsetof(sql3column, comment) == 32, "Unexpected offset");
+static_assert(offsetof(sql3column, is_primarykey) == 40, "Unexpected offset");
+static_assert(offsetof(sql3column, is_autoincrement) == 41, "Unexpected offset");
+static_assert(offsetof(sql3column, is_notnull) == 42, "Unexpected offset");
+static_assert(offsetof(sql3column, is_unique) == 43, "Unexpected offset");
+static_assert(offsetof(sql3column, pk_order) == 44, "Unexpected offset");
+static_assert(offsetof(sql3column, pk_conflictclause) == 48, "Unexpected offset");
+static_assert(offsetof(sql3column, notnull_conflictclause) == 52, "Unexpected offset");
+static_assert(offsetof(sql3column, unique_conflictclause) == 56, "Unexpected offset");
+static_assert(offsetof(sql3column, check_expr) == 60, "Unexpected offset");
+static_assert(offsetof(sql3column, default_expr) == 68, "Unexpected offset");
+static_assert(offsetof(sql3column, collate_name) == 76, "Unexpected offset");
+static_assert(offsetof(sql3column, foreignkey_clause) == 84, "Unexpected offset");
+
+static_assert(offsetof(sql3foreignkey, table) == 0, "Unexpected offset");
+static_assert(offsetof(sql3foreignkey, num_columns) == 8, "Unexpected offset");
+static_assert(offsetof(sql3foreignkey, column_name) == 12, "Unexpected offset");
+static_assert(offsetof(sql3foreignkey, on_delete) == 16, "Unexpected offset");
+static_assert(offsetof(sql3foreignkey, on_update) == 20, "Unexpected offset");
+static_assert(offsetof(sql3foreignkey, match) == 24, "Unexpected offset");
+static_assert(offsetof(sql3foreignkey, deferrable) == 32, "Unexpected offset");

util/vtabutil/parse_test.go

@@ -0,0 +1,31 @@
+package vtabutil_test
+
+import (
+	"testing"
+
+	"github.com/ncruces/go-sqlite3/util/vtabutil"
+)
+
+func TestParse(t *testing.T) {
+	tab, err := vtabutil.Parse(`CREATE TABLE child(x REFERENCES parent)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if got := tab.Name; got != "child" {
+		t.Errorf("got %s, want child", got)
+	}
+	if got := len(tab.Columns); got != 1 {
+		t.Errorf("got %d, want 1", got)
+	}
+
+	col := tab.Columns[0]
+	if got := col.Name; got != "x" {
+		t.Errorf("got %s, want x", got)
+	}
+
+	fk := col.ForeignKeyClause
+	if got := fk.Table; got != "parent" {
+		t.Errorf("got %s, want parent", got)
+	}
+}

util/vtabutil/vtabutil.go

@@ -0,0 +1,2 @@
+// Package vtabutil implements virtual table utility functions.
+package vtabutil

vfs/adiantum/README.md

@@ -1,13 +1,7 @@
-# Go `"adiantum"` SQLite VFS
+# Go `adiantum` SQLite VFS
 
 This package wraps an SQLite VFS to offer encryption at rest.
 
-> [!WARNING]
-> This work was not certified by a cryptographer.
-> If you need vetted encryption, you should purchase the
-> [SQLite Encryption Extension](https://sqlite.org/see),
-> and either wrap it, or seek assistance wrapping it.
-
 The `"adiantum"` VFS wraps the default SQLite VFS using the
 [Adiantum](https://github.com/lukechampine/adiantum)
 tweakable and length-preserving encryption.\

vfs/const.go

@@ -51,6 +51,7 @@ const (
 	_IOERR_BEGIN_ATOMIC      _ErrorCode = util.IOERR_BEGIN_ATOMIC
 	_IOERR_COMMIT_ATOMIC     _ErrorCode = util.IOERR_COMMIT_ATOMIC
 	_IOERR_ROLLBACK_ATOMIC   _ErrorCode = util.IOERR_ROLLBACK_ATOMIC
+	_BUSY_SNAPSHOT           _ErrorCode = util.BUSY_SNAPSHOT
 	_CANTOPEN_FULLPATH       _ErrorCode = util.CANTOPEN_FULLPATH
 	_CANTOPEN_ISDIR          _ErrorCode = util.CANTOPEN_ISDIR
 	_READONLY_CANTINIT       _ErrorCode = util.READONLY_CANTINIT

vfs/memdb/README.md

@@ -1,4 +1,4 @@
-# Go `"memdb"` SQLite VFS
+# Go `memdb` SQLite VFS
 
 This package implements the [`"memdb"`](https://sqlite.org/src/doc/tip/src/memdb.c)
 SQLite VFS in pure Go.

vfs/os_bsd.go

@@ -29,5 +29,12 @@ func osReadLock(file *os.File, _ /*start*/, _ /*len*/ int64, _ /*timeout*/ time.
 }
 
 func osWriteLock(file *os.File, _ /*start*/, _ /*len*/ int64, _ /*timeout*/ time.Duration) _ErrorCode {
-	return osLock(file, unix.LOCK_EX|unix.LOCK_NB, _IOERR_LOCK)
+	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,
+		// then acquiring the new lock.
+		// This is a race, so return BUSY_SNAPSHOT to ensure the transaction is aborted.
+		return _BUSY_SNAPSHOT
+	}
+	return rc
 }

vfs/os_unix_lock.go

@@ -48,7 +48,7 @@ func osDowngradeLock(file *os.File, state LockLevel) _ErrorCode {
 			// In theory, the downgrade to a SHARED cannot fail because another
 			// process is holding an incompatible lock. If it does, this
 			// indicates that the other process is not following the locking
-			// protocol. If this happens, return _IOERR_RDLOCK. Returning
+			// protocol. If this happens, return IOERR_RDLOCK. Returning
 			// BUSY would confuse the upper layer.
 			return _IOERR_RDLOCK
 		}

vfs/readervfs/README.md

@@ -1,4 +1,4 @@
-# Go `"reader"` SQLite VFS
+# Go `reader` SQLite VFS
 
 This package implements a `"reader"` SQLite VFS
 that allows accessing any [`io.ReaderAt`](https://pkg.go.dev/io#ReaderAt)

vfs/shm_bsd.go

@@ -128,10 +128,11 @@ func (s *vfsShm) shmOpen() (rc _ErrorCode) {
 	}
 
 	// Lock and truncate the file, if not readonly.
+	// The lock is only released by closing the file.
 	if s.readOnly {
 		rc = _READONLY_CANTINIT
 	} else {
-		if rc := osWriteLock(f, 0, 0, 0); rc != _OK {
+		if rc := osLock(f, unix.LOCK_EX|unix.LOCK_NB, _IOERR_LOCK); rc != _OK {
 			return rc
 		}
 		if err := f.Truncate(0); err != nil {

vfs/tests/mptest/testdata/build.sh

@@ -7,7 +7,7 @@ ROOT=../../../../
 BINARYEN="$ROOT/tools/binaryen-version_117/bin"
 WASI_SDK="$ROOT/tools/wasi-sdk-22.0/bin"
 
-"$WASI_SDK/clang" --target=wasm32-wasi -std=c17 -flto -g0 -O2 \
+"$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -flto -g0 -O2 \
 	-o mptest.wasm main.c \
 	-I"$ROOT/sqlite3" \
 	-msimd128 -mmutable-globals \

vfs/tests/speedtest1/speedtest1_test.go

@@ -74,6 +74,8 @@ func initFlags() {
 			// keep test flags
 			os.Args[i] = arg
 			i++
+		case arg == "--":
+			// ignore this
 		default:
 			// collect everything else
 			options = append(options, arg)

vfs/tests/speedtest1/testdata/build.sh

@@ -7,7 +7,7 @@ ROOT=../../../../
 BINARYEN="$ROOT/tools/binaryen-version_117/bin"
 WASI_SDK="$ROOT/tools/wasi-sdk-22.0/bin"
 
-"$WASI_SDK/clang" --target=wasm32-wasi -std=c17 -flto -g0 -O2 \
+"$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -flto -g0 -O2 \
 	-o speedtest1.wasm main.c \
 	-I"$ROOT/sqlite3" \
 	-msimd128 -mmutable-globals \

vtab.go

@@ -16,14 +16,15 @@ func CreateModule[T VTab](db *Conn, name string, create, connect VTabConstructor
 	var flags int
 
 	const (
-		VTAB_CREATOR     = 0x01
-		VTAB_DESTROYER   = 0x02
-		VTAB_UPDATER     = 0x04
-		VTAB_RENAMER     = 0x08
-		VTAB_OVERLOADER  = 0x10
-		VTAB_CHECKER     = 0x20
-		VTAB_TXN         = 0x40
-		VTAB_SAVEPOINTER = 0x80
+		VTAB_CREATOR     = 0x001
+		VTAB_DESTROYER   = 0x002
+		VTAB_UPDATER     = 0x004
+		VTAB_RENAMER     = 0x008
+		VTAB_OVERLOADER  = 0x010
+		VTAB_CHECKER     = 0x020
+		VTAB_TXN         = 0x040
+		VTAB_SAVEPOINTER = 0x080
+		VTAB_SHADOWTABS  = 0x100
 	)
 
 	if create != nil {
@@ -52,6 +53,9 @@ func CreateModule[T VTab](db *Conn, name string, create, connect VTabConstructor
 	if implements[VTabSavepointer](vtab) {
 		flags |= VTAB_SAVEPOINTER
 	}
+	if implements[VTabShadowTabler](vtab) {
+		flags |= VTAB_SHADOWTABS
+	}
 
 	defer db.arena.mark()()
 	namePtr := db.arena.string(name)
@@ -174,6 +178,17 @@ type VTabOverloader interface {
 	FindFunction(arg int, name string) (ScalarFunction, IndexConstraintOp)
 }
 
+// A VTabShadowTabler allows a virtual table to protect the content
+// of shadow tables from being corrupted by hostile SQL.
+//
+// Implementing this interface signals that a virtual table named
+// "mumble" reserves all table names starting with "mumble_".
+type VTabShadowTabler interface {
+	VTab
+	// https://sqlite.org/vtab.html#the_xshadowname_method
+	ShadowTables()
+}
+
 // A VTabChecker allows a virtual table to report errors
 // to the PRAGMA integrity_check and PRAGMA quick_check commands.
 //