Tests.

Use sqlite-createtable-parser compiled to Wasm to parse the CREATE TABLE statement.

.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

@@ -131,7 +131,7 @@ jobs:
     - name: Test riscv64 (interpreter)
       run: GOARCH=riscv64 go test -v -short ./...
 
-    - name: Test s390x (big-endian, z/OS)
+    - name: Test s390x (big-endian, z/OS demo)
       run: GOARCH=s390x go test -v -short -tags sqlite3_flock ./...
 
   test-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)
@@ -51,12 +53,12 @@ Go, wazero and [`x/sys`](https://pkg.go.dev/golang.org/x/sys) are the _only_ run
   provides [Unicode aware](https://sqlite.org/src/dir/ext/icu) functions.
 - [`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
 

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
 	}

driver/driver_test.go

@@ -13,8 +13,8 @@ import (
 
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 	"github.com/ncruces/go-sqlite3/internal/util"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
 	"github.com/ncruces/go-sqlite3/vfs"
 )
 

driver/savepoint_test.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
 	_ "github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 

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).

ext/array/array.go

@@ -16,7 +16,7 @@ import (
 // ints, floats, bools, strings or byte slices,
 // using [sqlite3.BindPointer] or [sqlite3.Pointer].
 func Register(db *sqlite3.Conn) {
-	sqlite3.CreateModule[array](db, "array", nil,
+	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

@@ -11,7 +11,7 @@ import (
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	"github.com/ncruces/go-sqlite3/ext/array"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func Example_driver() {

ext/blobio/blob_test.go

@@ -12,7 +12,7 @@ import (
 	_ "github.com/ncruces/go-sqlite3/embed"
 	"github.com/ncruces/go-sqlite3/ext/array"
 	"github.com/ncruces/go-sqlite3/ext/blobio"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 	_ "github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 

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 (
+	"errors"
+	"fmt"
+	"io"
+	"math"
+	"strconv"
+
+	"github.com/dchest/siphash"
+	"github.com/ncruces/go-sqlite3"
+)
+
+// Register registers the bloom_filter virtual table:
+//
+//	CREATE VIRTUAL TABLE foo USING bloom_filter(nElements, falseProb, kHashes)
+func Register(db *sqlite3.Conn) {
+	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, errors.New("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, errors.New("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, errors.New("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 = errors.New("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, errors.New("bloom: elements cannot be deleted")
+		}
+		return 0, errors.New("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
+	eof bool
+	arg *sqlite3.Value
+}
+
+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 TestRegister(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	bloom.Register(db)
+
+	err = db.Exec(`
+		CREATE VIRTUAL TABLE sports_cars USING bloom_filter(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()
+
+	bloom.Register(db)
+
+	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

@@ -9,9 +9,11 @@ package csv
 import (
 	"bufio"
 	"encoding/csv"
+	"errors"
 	"fmt"
 	"io"
 	"io/fs"
+	"strconv"
 	"strings"
 
 	"github.com/ncruces/go-sqlite3"
@@ -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, errors.New(`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)
@@ -110,11 +122,13 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) {
 }
 
 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

@@ -8,7 +8,7 @@ import (
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	"github.com/ncruces/go-sqlite3/ext/csv"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func Example() {
@@ -63,14 +63,16 @@ func TestRegister(t *testing.T) {
 	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,6 +115,50 @@ Robert	"Griesemer"	"gri"`
 	}
 }
 
+func TestAffinity(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	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()
 

ext/csv/types.go

@@ -0,0 +1,54 @@
+package csv
+
+import (
+	_ "embed"
+	"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
+	}
+	defer tab.Close()
+
+	types := make([]affinity, tab.NumColumns())
+	for i := range types {
+		col := tab.Column(i)
+		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,35 @@
+package csv
+
+import (
+	_ "embed"
+	"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_test.go

@@ -11,7 +11,7 @@ import (
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	"github.com/ncruces/go-sqlite3/ext/fileio"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func Test_lsmode(t *testing.T) {

ext/fileio/fsdir_test.go

@@ -12,7 +12,7 @@ import (
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	"github.com/ncruces/go-sqlite3/ext/fileio"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func Test_fsdir(t *testing.T) {

ext/fileio/write_test.go

@@ -10,7 +10,7 @@ import (
 	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func Test_writefile(t *testing.T) {

ext/hash/hash_test.go

@@ -10,7 +10,7 @@ import (
 	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 	_ "golang.org/x/crypto/blake2b"
 	_ "golang.org/x/crypto/blake2s"
 	_ "golang.org/x/crypto/md4"

ext/lines/lines.go

@@ -34,13 +34,13 @@ func Register(db *sqlite3.Conn) {
 // 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,
+	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[lines](db, "lines_read", nil,
+	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)

ext/lines/lines_test.go

@@ -14,7 +14,7 @@ import (
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	"github.com/ncruces/go-sqlite3/ext/lines"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func Example() {

ext/pivot/pivot.go

@@ -65,7 +65,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, errors.New("pivot: column definition query expects 2 result columns")
 	}
 	for stmt.Step() {
 		name := sqlite3.QuoteIdentifier(stmt.ColumnText(1))
@@ -83,7 +83,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, errors.New("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

@@ -9,7 +9,7 @@ import (
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	"github.com/ncruces/go-sqlite3/ext/pivot"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 // https://antonz.org/sqlite-pivot-table/

ext/statement/stmt.go

@@ -8,7 +8,7 @@ package statement
 
 import (
 	"encoding/json"
-	"fmt"
+	"errors"
 	"strconv"
 	"strings"
 	"unsafe"
@@ -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, errors.New("statement: wrong number of arguments")
 	}
 
 	sql := "SELECT * FROM\n" + arg[0]

ext/statement/stmt_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	"github.com/ncruces/go-sqlite3/ext/statement"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func Example() {

ext/stats/TODO.md

@@ -41,7 +41,16 @@ https://sqlite.org/lang_aggfunc.html
 - [X] `RANK() OVER window`
 - [X] `DENSE_RANK() OVER window`
 - [X] `PERCENT_RANK() OVER window`
-- [ ] `PERCENTILE_CONT(percentile) OVER window`
-- [ ] `PERCENTILE_DISC(percentile) OVER window`
 
-https://sqlite.org/windowfunctions.html#builtins
+https://sqlite.org/windowfunctions.html#builtins
+
+## Boolean aggregates
+
+- [X] `EVERY(boolean)`
+- [X] `SOME(boolean)`
+
+## Additional aggregates
+
+- [X] `MEDIAN(expression)`
+- [X] `PERCENTILE_CONT(expression, fraction)`
+- [X] `PERCENTILE_DISC(expression, fraction)`

ext/stats/boolean.go

@@ -0,0 +1,46 @@
+package stats
+
+import "github.com/ncruces/go-sqlite3"
+
+const (
+	every = iota
+	some
+)
+
+func newBoolean(kind int) func() sqlite3.AggregateFunction {
+	return func() sqlite3.AggregateFunction { return &boolean{kind: kind} }
+}
+
+type boolean struct {
+	count int
+	total int
+	kind  int
+}
+
+func (b *boolean) Value(ctx sqlite3.Context) {
+	if b.kind == every {
+		ctx.ResultBool(b.count == b.total)
+	} else {
+		ctx.ResultBool(b.count > 0)
+	}
+}
+
+func (b *boolean) Step(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	if arg[0].Type() == sqlite3.NULL {
+		return
+	}
+	if arg[0].Bool() {
+		b.count++
+	}
+	b.total++
+}
+
+func (b *boolean) Inverse(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	if arg[0].Type() == sqlite3.NULL {
+		return
+	}
+	if arg[0].Bool() {
+		b.count--
+	}
+	b.total--
+}

ext/stats/boolean_test.go

@@ -0,0 +1,74 @@
+package stats_test
+
+import (
+	"testing"
+
+	"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"
+)
+
+func TestRegister_boolean(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	stats.Register(db)
+
+	err = db.Exec(`CREATE TABLE data (x)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`INSERT INTO data (x) VALUES (4), (7.0), (13), (NULL), (16), (3.14)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`
+		SELECT
+			every(x > 0),
+			every(x > 10),
+			some(x > 10),
+			some(x > 20)
+		FROM data`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if stmt.Step() {
+		if got := stmt.ColumnBool(0); got != true {
+			t.Errorf("got %v, want true", got)
+		}
+		if got := stmt.ColumnBool(1); got != false {
+			t.Errorf("got %v, want false", got)
+		}
+		if got := stmt.ColumnBool(2); got != true {
+			t.Errorf("got %v, want true", got)
+		}
+		if got := stmt.ColumnBool(3); got != false {
+			t.Errorf("got %v, want false", got)
+		}
+	}
+	stmt.Close()
+
+	stmt, _, err = db.Prepare(`SELECT every(x > 10) OVER (ROWS 1 PRECEDING) FROM data`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want := [...]bool{false, false, false, true, true, false}
+	for i := 0; stmt.Step(); i++ {
+		if got := stmt.ColumnBool(0); got != want[i] {
+			t.Errorf("got %v, want %v", got, want[i])
+		}
+		if got := stmt.ColumnType(0); got != sqlite3.INTEGER {
+			t.Errorf("got %v, want INTEGER", got)
+		}
+	}
+	stmt.Close()
+}

ext/stats/percentile.go

@@ -0,0 +1,94 @@
+package stats
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"slices"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/ncruces/sort/quick"
+)
+
+const (
+	median = iota
+	percentile_cont
+	percentile_disc
+)
+
+func newPercentile(kind int) func() sqlite3.AggregateFunction {
+	return func() sqlite3.AggregateFunction { return &percentile{kind: kind} }
+}
+
+type percentile struct {
+	nums []float64
+	arg1 []byte
+	kind int
+}
+
+func (q *percentile) Step(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	if a := arg[0]; a.NumericType() != sqlite3.NULL {
+		q.nums = append(q.nums, a.Float())
+	}
+	if q.kind != median {
+		q.arg1 = arg[1].Blob(q.arg1[:0])
+	}
+}
+
+func (q *percentile) Inverse(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	// Implementing inverse allows certain queries that don't really need it to succeed.
+	ctx.ResultError(util.ErrorString("percentile: may not be used as a window function"))
+}
+
+func (q *percentile) Value(ctx sqlite3.Context) {
+	if len(q.nums) == 0 {
+		return
+	}
+
+	var (
+		err    error
+		float  float64
+		floats []float64
+	)
+	if q.kind == median {
+		float, err = getPercentile(q.nums, 0.5, false)
+		ctx.ResultFloat(float)
+	} else if err = json.Unmarshal(q.arg1, &float); err == nil {
+		float, err = getPercentile(q.nums, float, q.kind == percentile_disc)
+		ctx.ResultFloat(float)
+	} else if err = json.Unmarshal(q.arg1, &floats); err == nil {
+		err = getPercentiles(q.nums, floats, q.kind == percentile_disc)
+		ctx.ResultJSON(floats)
+	}
+	if err != nil {
+		ctx.ResultError(fmt.Errorf("percentile: %w", err))
+	}
+}
+
+func getPercentile(nums []float64, pos float64, disc bool) (float64, error) {
+	if pos < 0 || pos > 1 {
+		return 0, util.ErrorString("invalid pos")
+	}
+
+	i, f := math.Modf(pos * float64(len(nums)-1))
+	m0 := quick.Select(nums, int(i))
+
+	if f == 0 || disc {
+		return m0, nil
+	}
+
+	m1 := slices.Min(nums[int(i)+1:])
+	return math.FMA(f, m1, -math.FMA(f, m0, -m0)), nil
+}
+
+func getPercentiles(nums []float64, pos []float64, disc bool) error {
+	for i := range pos {
+		v, err := getPercentile(nums, pos[i], disc)
+		if err != nil {
+			return err
+		}
+		pos[i] = v
+	}
+	return nil
+}

ext/stats/percentile_test.go

@@ -0,0 +1,124 @@
+package stats_test
+
+import (
+	"slices"
+	"testing"
+
+	"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"
+)
+
+func TestRegister_percentile(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	stats.Register(db)
+
+	err = db.Exec(`CREATE TABLE data (x)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`INSERT INTO data (x) VALUES (4), (7.0), ('13'), (NULL), (16)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`
+		SELECT
+			median(x),
+			percentile_disc(x, 0.5),
+			percentile_cont(x, '[0.25, 0.5, 0.75]')
+		FROM data`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if stmt.Step() {
+		if got := stmt.ColumnFloat(0); got != 10 {
+			t.Errorf("got %v, want 10", got)
+		}
+		if got := stmt.ColumnFloat(1); got != 7 {
+			t.Errorf("got %v, want 7", got)
+		}
+		var got []float64
+		if err := stmt.ColumnJSON(2, &got); err != nil {
+			t.Error(err)
+		}
+		if !slices.Equal(got, []float64{6.25, 10, 13.75}) {
+			t.Errorf("got %v, want [6.25 10 13.75]", got)
+		}
+	}
+	stmt.Close()
+
+	stmt, _, err = db.Prepare(`
+		SELECT
+			median(x),
+			percentile_disc(x, 0.5),
+			percentile_cont(x, '[0.25, 0.5, 0.75]')
+		FROM data
+		WHERE x < 5`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if stmt.Step() {
+		if got := stmt.ColumnFloat(0); got != 4 {
+			t.Errorf("got %v, want 4", got)
+		}
+		if got := stmt.ColumnFloat(1); got != 4 {
+			t.Errorf("got %v, want 4", got)
+		}
+		var got []float64
+		if err := stmt.ColumnJSON(2, &got); err != nil {
+			t.Error(err)
+		}
+		if !slices.Equal(got, []float64{4, 4, 4}) {
+			t.Errorf("got %v, want [4 4 4]", got)
+		}
+	}
+	stmt.Close()
+
+	stmt, _, err = db.Prepare(`
+		SELECT
+			median(x),
+			percentile_disc(x, 0.5),
+			percentile_cont(x, '[0.25, 0.5, 0.75]')
+		FROM data
+		WHERE x < 0`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if stmt.Step() {
+		if got := stmt.ColumnType(0); got != sqlite3.NULL {
+			t.Error("want NULL")
+		}
+		if got := stmt.ColumnType(1); got != sqlite3.NULL {
+			t.Error("want NULL")
+		}
+		if got := stmt.ColumnType(2); got != sqlite3.NULL {
+			t.Error("want NULL")
+		}
+	}
+	stmt.Close()
+
+	stmt, _, err = db.Prepare(`
+		SELECT
+			percentile_disc(x, -2),
+			percentile_cont(x, +2),
+			percentile_cont(x, ''),
+			percentile_cont(x, '[100]')
+		FROM data`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if stmt.Step() {
+		t.Error("want error")
+	}
+	stmt.Close()
+}

ext/stats/stats.go

@@ -18,6 +18,11 @@
 //   - regr_slope: slope of the least-squares-fit linear equation
 //   - regr_intercept: y-intercept of the least-squares-fit linear equation
 //   - regr_json: all regr stats in a JSON object
+//   - percentile_disc: discrete percentile
+//   - percentile_cont: continuous percentile
+//   - median: median value
+//   - every: boolean and
+//   - some: boolean or
 //
 // These join the [Built-in Aggregate Functions]:
 //   - count: count rows/values
@@ -26,9 +31,16 @@
 //   - min: minimum value
 //   - max: maximum value
 //
+// And the [Built-in Window Functions]:
+//   - rank: rank of the current row with gaps
+//   - dense_rank: rank of the current row without gaps
+//   - percent_rank: relative rank of the row
+//   - cume_dist: cumulative distribution
+//
 // See: [ANSI SQL Aggregate Functions]
 //
 // [Built-in Aggregate Functions]: https://sqlite.org/lang_aggfunc.html
+// [Built-in Window Functions]: https://sqlite.org/windowfunctions.html#builtins
 // [ANSI SQL Aggregate Functions]: https://www.oreilly.com/library/view/sql-in-a/9780596155322/ch04s02.html
 package stats
 
@@ -54,6 +66,11 @@ func Register(db *sqlite3.Conn) {
 	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

@@ -7,7 +7,7 @@ import (
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	"github.com/ncruces/go-sqlite3/ext/stats"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func TestRegister_variance(t *testing.T) {
@@ -40,8 +40,6 @@ func TestRegister_variance(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer stmt.Close()
-
 	if stmt.Step() {
 		if got := stmt.ColumnFloat(0); got != 40 {
 			t.Errorf("got %v, want 40", got)
@@ -62,24 +60,23 @@ func TestRegister_variance(t *testing.T) {
 			t.Errorf("got %v, want √22.5", got)
 		}
 	}
+	stmt.Close()
 
-	{
-		stmt, _, err := db.Prepare(`SELECT var_samp(x) OVER (ROWS 1 PRECEDING) FROM data`)
-		if err != nil {
-			t.Fatal(err)
+	stmt, _, err = db.Prepare(`SELECT var_samp(x) OVER (ROWS 1 PRECEDING) FROM data`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want := [...]float64{0, 4.5, 18, 0, 0}
+	for i := 0; stmt.Step(); i++ {
+		if got := stmt.ColumnFloat(0); got != want[i] {
+			t.Errorf("got %v, want %v", got, want[i])
 		}
-		defer stmt.Close()
-
-		want := [...]float64{0, 4.5, 18, 0, 0}
-		for i := 0; stmt.Step(); i++ {
-			if got := stmt.ColumnFloat(0); got != want[i] {
-				t.Errorf("got %v, want %v", got, want[i])
-			}
-			if got := stmt.ColumnType(0); (got == sqlite3.FLOAT) != (want[i] != 0) {
-				t.Errorf("got %v, want %v", got, want[i])
-			}
+		if got := stmt.ColumnType(0); (got == sqlite3.FLOAT) != (want[i] != 0) {
+			t.Errorf("got %v, want %v", got, want[i])
 		}
 	}
+	stmt.Close()
 }
 
 func TestRegister_covariance(t *testing.T) {
@@ -113,8 +110,6 @@ func TestRegister_covariance(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer stmt.Close()
-
 	if stmt.Step() {
 		if got := stmt.ColumnFloat(0); got != 0.9881049293224639 {
 			t.Errorf("got %v, want 0.9881049293224639", got)
@@ -159,24 +154,23 @@ func TestRegister_covariance(t *testing.T) {
 			t.Errorf("got %v, want 5", got)
 		}
 	}
+	stmt.Close()
 
-	{
-		stmt, _, err := db.Prepare(`SELECT covar_samp(y, x) OVER (ROWS 1 PRECEDING) FROM data`)
-		if err != nil {
-			t.Fatal(err)
+	stmt, _, err = db.Prepare(`SELECT covar_samp(y, x) OVER (ROWS 1 PRECEDING) FROM data`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want := [...]float64{0, 10, 30, 75, 22.5}
+	for i := 0; stmt.Step(); i++ {
+		if got := stmt.ColumnFloat(0); got != want[i] {
+			t.Errorf("got %v, want %v", got, want[i])
 		}
-		defer stmt.Close()
-
-		want := [...]float64{0, 10, 30, 75, 22.5}
-		for i := 0; stmt.Step(); i++ {
-			if got := stmt.ColumnFloat(0); got != want[i] {
-				t.Errorf("got %v, want %v", got, want[i])
-			}
-			if got := stmt.ColumnType(0); (got == sqlite3.FLOAT) != (want[i] != 0) {
-				t.Errorf("got %v, want %v", got, want[i])
-			}
+		if got := stmt.ColumnType(0); (got == sqlite3.FLOAT) != (want[i] != 0) {
+			t.Errorf("got %v, want %v", got, want[i])
 		}
 	}
+	stmt.Close()
 }
 
 func Benchmark_average(b *testing.B) {

ext/unicode/unicode_test.go

@@ -7,7 +7,7 @@ import (
 
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func TestRegister(t *testing.T) {

ext/zorder/zorder_test.go

@@ -7,7 +7,7 @@ import (
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	"github.com/ncruces/go-sqlite3/ext/zorder"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func TestRegister_zorder(t *testing.T) {

func_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	"github.com/ncruces/go-sqlite3/ext/unicode"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func ExampleConn_CreateCollation() {

go.mod

@@ -3,14 +3,16 @@ module github.com/ncruces/go-sqlite3
 go 1.21
 
 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.2
-	golang.org/x/crypto v0.23.0
+	github.com/tetratelabs/wazero v1.7.3
+	golang.org/x/crypto v0.24.0
 	golang.org/x/sync v0.7.0
-	golang.org/x/sys v0.20.0
-	golang.org/x/text v0.15.0
-	lukechampine.com/adiantum v1.1.0
+	golang.org/x/sys v0.21.0
+	golang.org/x/text v0.16.0
+	lukechampine.com/adiantum v1.1.1
 )
 
 retract v0.4.0 // tagged from the wrong branch

go.sum

@@ -1,16 +1,20 @@
+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/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=
+github.com/ncruces/sort v0.1.2/go.mod h1:vEJUTBJtebIuCMmXD18GKo5GJGhsay+xZFOoBEIXFmE=
 github.com/psanford/httpreadat v0.1.0 h1:VleW1HS2zO7/4c7c7zNl33fO6oYACSagjJIyMIwZLUE=
 github.com/psanford/httpreadat v0.1.0/go.mod h1:Zg7P+TlBm3bYbyHTKv/EdtSJZn3qwbPwpfZ/I9GKCRE=
-github.com/tetratelabs/wazero v1.7.2 h1:1+z5nXJNwMLPAWaTePFi49SSTL0IMx/i3Fg8Yc25GDc=
-github.com/tetratelabs/wazero v1.7.2/go.mod h1:ytl6Zuh20R/eROuyDaGPkp82O9C/DJfXAwJfQ3X6/7Y=
-golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
-golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
+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/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
 golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
-golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
-golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-lukechampine.com/adiantum v1.1.0 h1:Y56WsdnHGgl62EmxkwJz0qvlnWOUqJmVYljwRPj7ovY=
-lukechampine.com/adiantum v1.1.0/go.mod h1:LrAYVnTYLnUtE/yMp5bQr0HstAf060YUF8nM0B6+rUw=
+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/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=
+lukechampine.com/adiantum v1.1.1/go.mod h1:LrAYVnTYLnUtE/yMp5bQr0HstAf060YUF8nM0B6+rUw=

go.work.sum

@@ -0,0 +1,7 @@
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
+golang.org/x/term v0.21.0/go.mod h1:ooXLefLobQVslOqselCNF4SxFAaoS6KujMbsGzSDmX0=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=

gormlite/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

@@ -3,7 +3,7 @@ module github.com/ncruces/go-sqlite3/gormlite
 go 1.21
 
 require (
-	github.com/ncruces/go-sqlite3 v0.16.0
+	github.com/ncruces/go-sqlite3 v0.16.3
 	gorm.io/gorm v1.25.10
 )
 
@@ -11,6 +11,6 @@ require (
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/ncruces/julianday v1.0.0 // indirect
-	github.com/tetratelabs/wazero v1.7.2 // indirect
-	golang.org/x/sys v0.20.0 // indirect
+	github.com/tetratelabs/wazero v1.7.3 // indirect
+	golang.org/x/sys v0.21.0 // indirect
 )

gormlite/go.sum

@@ -2,15 +2,15 @@ github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
 github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
-github.com/ncruces/go-sqlite3 v0.16.0 h1:O7eULuEjvSBnS1QCN+dDL/ixLQZoUGWr466A02Gx1xc=
-github.com/ncruces/go-sqlite3 v0.16.0/go.mod h1:2TmAeD93ImsKXJRsUIKohfMvt17dZSbS6pzJ3k6YYFg=
+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.2 h1:1+z5nXJNwMLPAWaTePFi49SSTL0IMx/i3Fg8Yc25GDc=
-github.com/tetratelabs/wazero v1.7.2/go.mod h1:ytl6Zuh20R/eROuyDaGPkp82O9C/DJfXAwJfQ3X6/7Y=
-golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
-golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
-golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+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/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
+golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
 gorm.io/gorm v1.25.10 h1:dQpO+33KalOA+aFYGlK+EfxcI5MbO7EP2yYygwh9h+s=
 gorm.io/gorm v1.25.10/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=

gormlite/sqlite_test.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func TestDialector(t *testing.T) {

internal/alloc/alloc_other.go

@@ -0,0 +1,9 @@
+//go:build !(unix || windows) || sqlite3_nosys
+
+package alloc
+
+import "github.com/tetratelabs/wazero/experimental"
+
+func Virtual(cap, max uint64) experimental.LinearMemory {
+	return Slice(cap, max)
+}

internal/alloc/alloc_slice.go

@@ -1,21 +1,20 @@
 //go:build !(darwin || linux) || !(amd64 || arm64 || riscv64) || sqlite3_noshm || sqlite3_nosys
 
-package util
+package alloc
 
 import "github.com/tetratelabs/wazero/experimental"
 
-func sliceAlloc(cap, max uint64) experimental.LinearMemory {
-	return &sliceBuffer{make([]byte, cap), max}
+func Slice(cap, _ uint64) experimental.LinearMemory {
+	return &sliceMemory{make([]byte, 0, cap)}
 }
 
-type sliceBuffer struct {
+type sliceMemory struct {
 	buf []byte
-	max uint64
 }
 
-func (b *sliceBuffer) Free() {}
+func (b *sliceMemory) Free() {}
 
-func (b *sliceBuffer) Reallocate(size uint64) []byte {
+func (b *sliceMemory) Reallocate(size uint64) []byte {
 	if cap := uint64(cap(b.buf)); size > cap {
 		b.buf = append(b.buf[:cap], make([]byte, size-cap)...)
 	} else {

internal/alloc/alloc_unix.go

@@ -1,6 +1,6 @@
 //go:build unix && !sqlite3_nosys
 
-package util
+package alloc
 
 import (
 	"math"
@@ -9,7 +9,7 @@ import (
 	"golang.org/x/sys/unix"
 )
 
-func virtualAlloc(cap, max uint64) experimental.LinearMemory {
+func Virtual(_, max uint64) experimental.LinearMemory {
 	// Round up to the page size.
 	rnd := uint64(unix.Getpagesize() - 1)
 	max = (max + rnd) &^ rnd

internal/alloc/alloc_windows.go

@@ -1,6 +1,6 @@
 //go:build !sqlite3_nosys
 
-package util
+package alloc
 
 import (
 	"math"
@@ -11,7 +11,7 @@ import (
 	"golang.org/x/sys/windows"
 )
 
-func virtualAlloc(cap, max uint64) experimental.LinearMemory {
+func Virtual(_, max uint64) experimental.LinearMemory {
 	// Round up to the page size.
 	rnd := uint64(windows.Getpagesize() - 1)
 	max = (max + rnd) &^ rnd
@@ -32,7 +32,7 @@ func virtualAlloc(cap, max uint64) experimental.LinearMemory {
 	mem := virtualMemory{addr: r}
 	// SliceHeader, although deprecated, avoids a go vet warning.
 	sh := (*reflect.SliceHeader)(unsafe.Pointer(&mem.buf))
-	sh.Cap = int(max) // Not a bug.
+	sh.Cap = int(max)
 	sh.Data = r
 	return &mem
 }

internal/testcfg/testcfg.go

@@ -1,6 +1,7 @@
 package testcfg
 
 import (
+	"math/bits"
 	"os"
 	"path/filepath"
 
@@ -9,6 +10,10 @@ import (
 )
 
 func init() {
+	if bits.UintSize < 64 {
+		return
+	}
+
 	sqlite3.RuntimeConfig = wazero.NewRuntimeConfig().
 		WithMemoryCapacityFromMax(true).
 		WithMemoryLimitPages(1024)

internal/util/alloc_other.go

@@ -1,9 +0,0 @@
-//go:build !(unix || windows) || sqlite3_nosys
-
-package util
-
-import "github.com/tetratelabs/wazero/experimental"
-
-func virtualAlloc(cap, max uint64) experimental.LinearMemory {
-	return sliceAlloc(cap, max)
-}

internal/util/const.go

@@ -1,6 +1,6 @@
 package util
 
-// https://sqlite.com/matrix/rescode.html
+// https://sqlite.com/rescode.html
 const (
 	OK = 0 /* Successful result */
 

internal/util/json.go

@@ -26,7 +26,7 @@ func (j JSON) Scan(value any) error {
 		buf = v.AppendFormat(buf, time.RFC3339Nano)
 		buf = append(buf, '"')
 	case nil:
-		buf = append(buf, "null"...)
+		buf = []byte("null")
 	default:
 		panic(AssertErr())
 	}

internal/util/mmap.go

@@ -1,4 +1,4 @@
-//go:build (darwin || linux) && (amd64 || arm64 || riscv64) && !(sqlite3_noshm || sqlite3_nosys)
+//go:build unix && (amd64 || arm64 || riscv64) && !(sqlite3_noshm || sqlite3_nosys)
 
 package util
 
@@ -7,6 +7,7 @@ import (
 	"os"
 	"unsafe"
 
+	"github.com/ncruces/go-sqlite3/internal/alloc"
 	"github.com/tetratelabs/wazero/api"
 	"github.com/tetratelabs/wazero/experimental"
 	"golang.org/x/sys/unix"
@@ -14,7 +15,7 @@ import (
 
 func withAllocator(ctx context.Context) context.Context {
 	return experimental.WithMemoryAllocator(ctx,
-		experimental.MemoryAllocatorFunc(virtualAlloc))
+		experimental.MemoryAllocatorFunc(alloc.Virtual))
 }
 
 type mmapState struct {

internal/util/mmap_other.go

@@ -1,10 +1,11 @@
-//go:build !(darwin || linux) || !(amd64 || arm64 || riscv64) || sqlite3_noshm || sqlite3_nosys
+//go:build !unix || !(amd64 || arm64 || riscv64) || sqlite3_noshm || sqlite3_nosys
 
 package util
 
 import (
 	"context"
 
+	"github.com/ncruces/go-sqlite3/internal/alloc"
 	"github.com/tetratelabs/wazero/experimental"
 )
 
@@ -14,8 +15,8 @@ func withAllocator(ctx context.Context) context.Context {
 	return experimental.WithMemoryAllocator(ctx,
 		experimental.MemoryAllocatorFunc(func(cap, max uint64) experimental.LinearMemory {
 			if cap == max {
-				return virtualAlloc(cap, max)
+				return alloc.Virtual(cap, max)
 			}
-			return sliceAlloc(cap, max)
+			return alloc.Slice(cap, max)
 		}))
 }

json.go

@@ -5,7 +5,8 @@ import "github.com/ncruces/go-sqlite3/internal/util"
 // JSON returns a value that can be used as an argument to
 // [database/sql.DB.Exec], [database/sql.Row.Scan] and similar methods to
 // store value as JSON, or decode JSON into value.
-// JSON should NOT be used with [BindJSON] or [ResultJSON].
+// JSON should NOT be used with [Stmt.BindJSON], [Stmt.ColumnJSON],
+// [Value.JSON], or [Context.ResultJSON].
 func JSON(value any) any {
 	return util.JSON{Value: value}
 }

pointer.go

@@ -4,7 +4,8 @@ import "github.com/ncruces/go-sqlite3/internal/util"
 
 // Pointer returns a pointer to a value that can be used as an argument to
 // [database/sql.DB.Exec] and similar methods.
-// Pointer should NOT be used with [BindPointer] or [ResultPointer].
+// Pointer should NOT be used with [Stmt.BindPointer],
+// [Value.Pointer], or [Context.ResultPointer].
 //
 // https://sqlite.org/bindptr.html
 func Pointer[T any](value T) any {

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;
   }

stmt.go

@@ -441,12 +441,12 @@ func (s *Stmt) ColumnOriginName(col int) string {
 // ColumnBool returns the value of the result column as a bool.
 // The leftmost column of the result set has the index 0.
 // SQLite does not have a separate boolean storage class.
-// Instead, boolean values are retrieved as integers,
+// Instead, boolean values are retrieved as numbers,
 // with 0 converted to false and any other value to true.
 //
 // https://sqlite.org/c3ref/column_blob.html
 func (s *Stmt) ColumnBool(col int) bool {
-	return s.ColumnInt64(col) != 0
+	return s.ColumnFloat(col) != 0
 }
 
 // ColumnInt returns the value of the result column as an int.
@@ -564,7 +564,7 @@ func (s *Stmt) ColumnJSON(col int, ptr any) error {
 	var data []byte
 	switch s.ColumnType(col) {
 	case NULL:
-		data = append(data, "null"...)
+		data = []byte("null")
 	case TEXT:
 		data = s.ColumnRawText(col)
 	case BLOB:

tests/backup_test.go

@@ -6,7 +6,7 @@ import (
 
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 	"github.com/ncruces/go-sqlite3/vfs"
 )
 

tests/blob_test.go

@@ -11,7 +11,7 @@ import (
 
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func TestBlob(t *testing.T) {

tests/bradfitz/sql_test.go

@@ -14,7 +14,7 @@ import (
 
 	_ "github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 type Tester interface {

tests/conn_test.go

@@ -11,7 +11,7 @@ import (
 
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 	_ "github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 

tests/db_test.go

@@ -9,7 +9,7 @@ import (
 
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 	"github.com/ncruces/go-sqlite3/vfs"
 	_ "github.com/ncruces/go-sqlite3/vfs/adiantum"
 	_ "github.com/ncruces/go-sqlite3/vfs/memdb"

tests/driver_test.go

@@ -6,7 +6,7 @@ import (
 
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func TestDriver(t *testing.T) {

tests/ext_test.go

@@ -5,7 +5,7 @@ import (
 
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func Test_base64(t *testing.T) {

tests/func_test.go

@@ -6,7 +6,7 @@ import (
 
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func TestCreateFunction(t *testing.T) {

tests/json_test.go

@@ -10,7 +10,7 @@ import (
 	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 	"github.com/ncruces/julianday"
 )
 

tests/parallel/parallel_test.go

@@ -12,7 +12,7 @@ import (
 
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 	"github.com/ncruces/go-sqlite3/vfs"
 	_ "github.com/ncruces/go-sqlite3/vfs/adiantum"
 	"github.com/ncruces/go-sqlite3/vfs/memdb"
@@ -61,7 +61,6 @@ func Test_memdb(t *testing.T) {
 		iter = 5000
 	}
 
-	memdb.Delete("test.db")
 	memdb.Create("test.db", nil)
 	name := "file:/test.db?vfs=memdb"
 	testParallel(t, name, iter)
@@ -142,11 +141,42 @@ func TestChildProcess(t *testing.T) {
 	testParallel(t, name, 1000)
 }
 
+func Benchmark_parallel(b *testing.B) {
+	if !vfs.SupportsSharedMemory {
+		b.Skip("skipping without shared memory")
+	}
+
+	sqlite3.Initialize()
+	b.ResetTimer()
+
+	name := "file:" +
+		filepath.Join(b.TempDir(), "test.db") +
+		"?_pragma=busy_timeout(10000)" +
+		"&_pragma=journal_mode(truncate)" +
+		"&_pragma=synchronous(off)"
+	testParallel(b, name, b.N)
+}
+
+func Benchmark_wal(b *testing.B) {
+	if !vfs.SupportsSharedMemory {
+		b.Skip("skipping without shared memory")
+	}
+
+	sqlite3.Initialize()
+	b.ResetTimer()
+
+	name := "file:" +
+		filepath.Join(b.TempDir(), "test.db") +
+		"?_pragma=busy_timeout(10000)" +
+		"&_pragma=journal_mode(wal)" +
+		"&_pragma=synchronous(off)"
+	testParallel(b, name, b.N)
+}
+
 func Benchmark_memdb(b *testing.B) {
 	sqlite3.Initialize()
 	b.ResetTimer()
 
-	memdb.Delete("test.db")
 	memdb.Create("test.db", nil)
 	name := "file:/test.db?vfs=memdb"
 	testParallel(b, name, b.N)

tests/stmt_test.go

@@ -3,12 +3,13 @@ package tests
 import (
 	"encoding/json"
 	"math"
+	"math/bits"
 	"testing"
 	"time"
 
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func TestStmt(t *testing.T) {
@@ -617,6 +618,9 @@ func TestStmt_ColumnTime(t *testing.T) {
 }
 
 func TestStmt_Error(t *testing.T) {
+	if bits.UintSize < 64 {
+		t.Skip("skipping on 32-bit")
+	}
 	t.Parallel()
 
 	db, err := sqlite3.Open(":memory:")

tests/time_test.go

@@ -10,7 +10,7 @@ import (
 	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func TestTimeFormat_Encode(t *testing.T) {

tests/txn_test.go

@@ -7,7 +7,7 @@ import (
 
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 	_ "github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 

tests/vfs_test.go

@@ -6,7 +6,7 @@ import (
 
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 	"github.com/ncruces/go-sqlite3/vfs/memdb"
 	"github.com/ncruces/go-sqlite3/vfs/readervfs"
 )

tests/wal_test.go

@@ -1,13 +1,13 @@
 package tests
 
 import (
-	"os"
 	"path/filepath"
 	"testing"
 
 	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 	"github.com/ncruces/go-sqlite3/vfs"
 )
 
@@ -52,26 +52,55 @@ func TestWAL_readonly(t *testing.T) {
 	}
 	t.Parallel()
 
-	tmp := filepath.Join(t.TempDir(), "test.db")
-	err := os.WriteFile(tmp, walDB, 0666)
+	tmp := filepath.ToSlash(filepath.Join(t.TempDir(), "test.db"))
+
+	db1, err := driver.Open("file:"+tmp+"?_pragma=journal_mode(wal)&_txlock=immediate", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db1.Close()
+
+	db2, err := driver.Open("file:"+tmp+"?_pragma=journal_mode(wal)&mode=ro", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db2.Close()
+
+	// Create the table using the first (writable) connection.
+	_, err = db1.Exec(`
+		CREATE TABLE t(id INTEGER PRIMARY KEY, name TEXT);
+		INSERT INTO t(name) VALUES('alice');
+	`)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	db, err := sqlite3.OpenFlags(tmp, sqlite3.OPEN_READONLY)
+	// Select the data using the second (readonly) connection.
+	var name string
+	err = db2.QueryRow("SELECT name FROM t").Scan(&name)
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer db.Close()
+	if name != "alice" {
+		t.Errorf("got %q want alice", name)
+	}
 
-	stmt, _, err := db.Prepare(`SELECT * FROM sqlite_master`)
+	// Update table.
+	_, err = db1.Exec(`
+		DELETE FROM t;
+		INSERT INTO t(name) VALUES('bob');
+	`)
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer stmt.Close()
 
-	if stmt.Step() {
-		t.Error("want no rows")
+	// Select the data using the second (readonly) connection.
+	err = db2.QueryRow("SELECT name FROM t").Scan(&name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if name != "bob" {
+		t.Errorf("got %q want bob", name)
 	}
 }
 

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/parse.go

@@ -0,0 +1,141 @@
+package vtabutil
+
+import (
+	"context"
+	"sync"
+
+	_ "embed"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/tetratelabs/wazero"
+	"github.com/tetratelabs/wazero/api"
+)
+
+const (
+	_NONE = iota
+	_MEMORY
+	_SYNTAX
+	_UNSUPPORTEDSQL
+
+	codeptr = 4
+	baseptr = 8
+)
+
+var (
+	//go:embed parse/sql3parse_table.wasm
+	binary  []byte
+	ctx     context.Context
+	once    sync.Once
+	runtime wazero.Runtime
+	module  wazero.CompiledModule
+)
+
+// Table holds metadata about a table.
+type Table struct {
+	mod api.Module
+	ptr uint32
+	sql string
+}
+
+// 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().WithDebugInfoEnabled(false)
+		runtime = wazero.NewRuntimeWithConfig(ctx, cfg)
+		module, err = runtime.CompileModule(ctx, binary)
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	mod, err := runtime.InstantiateModule(ctx, module, wazero.NewModuleConfig().WithName(""))
+	if err != nil {
+		return nil, err
+	}
+
+	if buf, ok := mod.Memory().Read(baseptr, uint32(len(sql))); ok {
+		copy(buf, sql)
+	}
+	r, err := mod.ExportedFunction("sql3parse_table").Call(ctx, baseptr, uint64(len(sql)), codeptr)
+	if err != nil {
+		return nil, err
+	}
+
+	c, _ := mod.Memory().ReadUint32Le(codeptr)
+	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")
+	}
+	if r[0] == 0 {
+		return nil, nil
+	}
+	return &Table{
+		sql: sql,
+		mod: mod,
+		ptr: uint32(r[0]),
+	}, nil
+}
+
+// Close closes a table handle.
+func (t *Table) Close() error {
+	mod := t.mod
+	t.mod = nil
+	return mod.Close(ctx)
+}
+
+// NumColumns returns the number of columns of the table.
+func (t *Table) NumColumns() int {
+	r, err := t.mod.ExportedFunction("sql3table_num_columns").Call(ctx, uint64(t.ptr))
+	if err != nil {
+		panic(err)
+	}
+	return int(int32(r[0]))
+}
+
+// Column returns data for the ith column of the table.
+//
+// https://sqlite.org/lang_createtable.html#column_definitions
+func (t *Table) Column(i int) Column {
+	r, err := t.mod.ExportedFunction("sql3table_get_column").Call(ctx, uint64(t.ptr), uint64(i))
+	if err != nil {
+		panic(err)
+	}
+	return Column{
+		tab: t,
+		ptr: uint32(r[0]),
+	}
+}
+
+func (t *Table) string(ptr uint32) string {
+	if ptr == 0 {
+		return ""
+	}
+	off, _ := t.mod.Memory().ReadUint32Le(ptr + 0)
+	len, _ := t.mod.Memory().ReadUint32Le(ptr + 4)
+	return t.sql[off-baseptr : off+len-baseptr]
+}
+
+// Column holds metadata about a column.
+type Column struct {
+	tab *Table
+	ptr uint32
+}
+
+// Type returns the declared type of a column.
+//
+// https://sqlite.org/lang_createtable.html#column_data_types
+func (c Column) Type() string {
+	r, err := c.tab.mod.ExportedFunction("sql3column_type").Call(ctx, uint64(c.ptr))
+	if err != nil {
+		panic(err)
+	}
+	return c.tab.string(uint32(r[0]))
+}

util/vtabutil/parse/.gitignore

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

util/vtabutil/parse/build.sh

@@ -0,0 +1,28 @@
+#!/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=c17 -flto -g0 -Oz \
+	-Wall -Wextra -Wno-unused-parameter -Wno-unused-function \
+	-o sql3parse_table.wasm sql3parse_table.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 \
+	$(awk '{print "-Wl,--export="$0}' exports.txt)
+
+trap 'rm -f sql3parse_table.tmp' EXIT
+"$BINARYEN/wasm-ctor-eval" -g -c _initialize sql3parse_table.wasm -o sql3parse_table.tmp
+"$BINARYEN/wasm-opt" -g --strip --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/exports.txt

@@ -0,0 +1,4 @@
+sql3parse_table
+sql3table_get_column
+sql3table_num_columns
+sql3column_type

util/vtabutil/vtabutil.go

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

value.go

@@ -68,12 +68,12 @@ func (v Value) NumericType() Datatype {
 
 // Bool returns the value as a bool.
 // SQLite does not have a separate boolean storage class.
-// Instead, boolean values are retrieved as integers,
+// Instead, boolean values are retrieved as numbers,
 // with 0 converted to false and any other value to true.
 //
 // https://sqlite.org/c3ref/value_blob.html
 func (v Value) Bool() bool {
-	return v.Int64() != 0
+	return v.Float() != 0
 }
 
 // Int returns the value as an int.
@@ -177,7 +177,7 @@ func (v Value) JSON(ptr any) error {
 	var data []byte
 	switch v.Type() {
 	case NULL:
-		data = append(data, "null"...)
+		data = []byte("null")
 	case TEXT:
 		data = v.RawText()
 	case BLOB:

vfs/README.md

@@ -46,7 +46,7 @@ to check if your build supports file locking.
 
 ### Write-Ahead Logging
 
-On 64-bit Linux and macOS, this module uses `mmap` to implement
+On 64-bit Unix, this module uses `mmap` to implement
 [shared-memory for the WAL-index](https://sqlite.org/wal.html#implementation_of_shared_memory_for_the_wal_index),
 like SQLite.
 
@@ -54,6 +54,11 @@ To allow `mmap` to work, each connection needs to reserve up to 4GB of address s
 To limit the address space each connection reserves,
 use [`WithMemoryLimitPages`](../tests/testcfg/testcfg.go).
 
+With [BSD locks](https://man.freebsd.org/cgi/man.cgi?query=flock&sektion=2)
+a WAL database can only be accessed by a single proccess.
+Other processes that attempt to access a database locked with BSD locks,
+will fail with the `SQLITE_PROTOCOL` error code.
+
 Otherwise, [WAL support is limited](https://sqlite.org/wal.html#noshm),
 and `EXCLUSIVE` locking mode must be set to create, read, and write WAL databases.
 To use `EXCLUSIVE` locking mode with the
@@ -79,8 +84,9 @@ The VFS can be customized with a few build tags:
 - `sqlite3_noshm` disables shared memory on all platforms.
 
 > [!IMPORTANT]
-> The default configuration of this package is compatible with
-> the standard [Unix and Windows SQLite VFSes](https://sqlite.org/vfs.html#multiple_vfses);
-> `sqlite3_flock` is compatible with the [`unix-flock` VFS](https://sqlite.org/compile.html#enable_locking_style).
-> If incompatible file locking is used, accessing databases concurrently with _other_ SQLite libraries
-> will eventually corrupt data.
+> The default configuration of this package is compatible with the standard
+> [Unix and Windows SQLite VFSes](https://sqlite.org/vfs.html#multiple_vfses);
+> `sqlite3_flock` builds are compatible with the
+> [`unix-flock` VFS](https://sqlite.org/compile.html#enable_locking_style).
+> If incompatible file locking is used, accessing databases concurrently with
+> _other_ SQLite libraries will eventually corrupt data.

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/adiantum/adiantum_test.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 	"github.com/ncruces/go-sqlite3/util/ioutil"
 	"github.com/ncruces/go-sqlite3/vfs"
 	"github.com/ncruces/go-sqlite3/vfs/adiantum"

vfs/api.go

@@ -168,8 +168,8 @@ type FileSharedMemory interface {
 // SharedMemory is a shared-memory WAL-index implementation.
 // Use [NewSharedMemory] to create a shared-memory.
 type SharedMemory interface {
-	shmMap(context.Context, api.Module, int32, int32, bool) (uint32, error)
-	shmLock(int32, int32, _ShmFlag) error
+	shmMap(context.Context, api.Module, int32, int32, bool) (uint32, _ErrorCode)
+	shmLock(int32, int32, _ShmFlag) _ErrorCode
 	shmUnmap(bool)
 	io.Closer
 }

vfs/const.go

@@ -47,9 +47,11 @@ const (
 	_IOERR_SHMMAP            _ErrorCode = util.IOERR_SHMMAP
 	_IOERR_SEEK              _ErrorCode = util.IOERR_SEEK
 	_IOERR_DELETE_NOENT      _ErrorCode = util.IOERR_DELETE_NOENT
+	_IOERR_GETTEMPPATH       _ErrorCode = util.IOERR_GETTEMPPATH
 	_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/file.go

@@ -95,6 +95,9 @@ func (vfsOS) OpenFilename(name *Filename, flags OpenFlag) (File, OpenFlag, error
 		f, err = osutil.OpenFile(name.String(), oflags, 0666)
 	}
 	if err != nil {
+		if name == nil {
+			return nil, flags, _IOERR_GETTEMPPATH
+		}
 		if errors.Is(err, syscall.EISDIR) {
 			return nil, flags, _CANTOPEN_ISDIR
 		}

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/memdb/memdb.go

@@ -75,11 +75,6 @@ func (memVFS) FullPathname(name string) (string, error) {
 type memDB struct {
 	name string
 
-	// +checklocks:lockMtx
-	pending *memFile
-	// +checklocks:lockMtx
-	reserved *memFile
-
 	// +checklocks:dataMtx
 	data []*[sectorSize]byte
 
@@ -88,6 +83,10 @@ type memDB struct {
 
 	// +checklocks:lockMtx
 	shared int
+	// +checklocks:lockMtx
+	reserved bool
+	// +checklocks:lockMtx
+	pending bool
 
 	// +checklocks:memoryMtx
 	refs int
@@ -214,24 +213,24 @@ func (m *memFile) Lock(lock vfs.LockLevel) error {
 
 	switch lock {
 	case vfs.LOCK_SHARED:
-		if m.pending != nil {
+		if m.pending {
 			return sqlite3.BUSY
 		}
 		m.shared++
 
 	case vfs.LOCK_RESERVED:
-		if m.reserved != nil {
+		if m.reserved {
 			return sqlite3.BUSY
 		}
-		m.reserved = m
+		m.reserved = true
 
 	case vfs.LOCK_EXCLUSIVE:
 		if m.lock < vfs.LOCK_PENDING {
-			if m.pending != nil {
+			if m.pending {
 				return sqlite3.BUSY
 			}
 			m.lock = vfs.LOCK_PENDING
-			m.pending = m
+			m.pending = true
 		}
 
 		for before := time.Now(); m.shared > 1; {
@@ -256,11 +255,11 @@ func (m *memFile) Unlock(lock vfs.LockLevel) error {
 	m.lockMtx.Lock()
 	defer m.lockMtx.Unlock()
 
-	if m.pending == m {
-		m.pending = nil
+	if m.pending && m.lock >= vfs.LOCK_PENDING {
+		m.pending = false
 	}
-	if m.reserved == m {
-		m.reserved = nil
+	if m.reserved && m.lock >= vfs.LOCK_RESERVED {
+		m.reserved = false
 	}
 	if lock < vfs.LOCK_SHARED {
 		m.shared--
@@ -275,7 +274,7 @@ func (m *memFile) CheckReservedLock() (bool, error) {
 	}
 	m.lockMtx.Lock()
 	defer m.lockMtx.Unlock()
-	return m.reserved != nil, nil
+	return m.reserved, nil
 }
 
 func (m *memFile) SectorSize() int {

vfs/memdb/memdb_test.go

@@ -7,7 +7,7 @@ import (
 
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/tests/testcfg"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 //go:embed testdata/wal.db

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_linux.go

@@ -56,7 +56,7 @@ func osLock(file *os.File, typ int16, start, len int64, timeout time.Duration, d
 			if timeout < time.Since(before) {
 				break
 			}
-			osSleep(time.Duration(rand.Int63n(int64(time.Millisecond))))
+			time.Sleep(time.Duration(rand.Int63n(int64(time.Millisecond))))
 		}
 	}
 	return osLockErrorCode(err, def)

vfs/os_std_sleep.go

@@ -1,9 +0,0 @@
-//go:build !windows || sqlite3_nosys
-
-package vfs
-
-import "time"
-
-func osSleep(d time.Duration) {
-	time.Sleep(d)
-}

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
 		}