Tests.

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

.github/actions/lfs/action.yml

@@ -0,0 +1,23 @@
+name: Git LFS pull
+description: Cached Git LFS pull.
+
+runs:
+  using: "composite"
+  steps:
+    - name: Create LFS file list
+      shell: bash
+      run: git lfs ls-files --long | cut -d ' ' -f1 | sort > .lfs-assets-id
+
+    - name: Restore LFS cache
+      uses: actions/cache@v4
+      with:
+        path: .git/lfs/objects
+        key: lfs-${{ hashFiles('.lfs-assets-id') }}
+        restore-keys: lfs-
+        enableCrossOsArchive: true
+
+    - name: Git LFS pull
+      shell: bash
+      run: |
+        git lfs pull
+        git lfs prune

.github/dependabot.yml

@@ -9,3 +9,7 @@ updates:
     directory: "/" # Location of package manifests
     schedule:
       interval: "daily"
+  - package-ecosystem: "github-actions" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "daily"

.github/workflows/bsd.yml

@@ -1,29 +0,0 @@
-name: BSD
-
-on:
-  workflow_dispatch:
-
-jobs:
-  test:
-    runs-on: macos-12
-
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        lfs: 'true'
-
-    - name: Set up
-      uses: actions/setup-go@v4
-      with:
-        go-version: stable
-
-    - name: Build
-      run: GOOS=freebsd go test -c ./...
-
-    - name: Test
-      uses: cross-platform-actions/action@v0.21.1
-      with:
-        operating_system: freebsd
-        version: '13.2'
-        sync_files: runner-to-vm
-        run: find . -name '*.test' -maxdepth 1 -exec {} -test.v \;

.github/workflows/build-test.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo 'set -eu' > test.sh
+
+for p in $(go list ./...); do
+  dir=".${p#github.com/ncruces/go-sqlite3}"
+  name="$(basename "$p").test"
+  (cd ${dir}; go test -c)
+  [ -f "${dir}/${name}" ] && echo "(cd ${dir}; ./${name} ${TESTFLAGS})" >> test.sh
+done

.github/workflows/cross.sh

@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
+set -euo pipefail
 
 echo android       ; GOOS=android   GOARCH=amd64 go build .
 echo darwin        ; GOOS=darwin    GOARCH=amd64 go build .
@@ -12,11 +13,15 @@ echo openbsd       ; GOOS=openbsd   GOARCH=amd64 go build .
 echo plan9         ; GOOS=plan9     GOARCH=amd64 go build .
 echo solaris       ; GOOS=solaris   GOARCH=amd64 go build .
 echo windows       ; GOOS=windows   GOARCH=amd64 go build .
-# echo aix         ; GOOS=aix       GOARCH=ppc64 go build .
+echo aix           ; GOOS=aix       GOARCH=ppc64 go build .
 echo js            ; GOOS=js        GOARCH=wasm  go build .
 echo wasip1        ; GOOS=wasip1    GOARCH=wasm  go build .
-echo darwin-flock  ; GOOS=darwin    GOARCH=amd64 go build -tags sqlite3_flock .
-echo darwin-nosys  ; GOOS=darwin    GOARCH=amd64 go build -tags sqlite3_nosys .
+echo linux-flock   ; GOOS=linux     GOARCH=amd64 go build -tags sqlite3_flock .
+echo linux-noshm   ; GOOS=linux     GOARCH=amd64 go build -tags sqlite3_noshm .
 echo linux-nosys   ; GOOS=linux     GOARCH=amd64 go build -tags sqlite3_nosys .
+echo darwin-flock  ; GOOS=darwin    GOARCH=amd64 go build -tags sqlite3_flock .
+echo darwin-noshm  ; GOOS=darwin    GOARCH=amd64 go build -tags sqlite3_noshm .
+echo darwin-nosys  ; GOOS=darwin    GOARCH=amd64 go build -tags sqlite3_nosys .
 echo windows-nosys ; GOOS=windows   GOARCH=amd64 go build -tags sqlite3_nosys .
 echo freebsd-nosys ; GOOS=freebsd   GOARCH=amd64 go build -tags sqlite3_nosys .
+echo solaris-flock ; GOOS=solaris   GOARCH=amd64 go build -tags sqlite3_flock .

.github/workflows/cross.yml

@@ -4,18 +4,13 @@ on:
   workflow_dispatch:
 
 jobs:
-  test:
+  build:
     runs-on: ubuntu-latest
 
     steps:
     - uses: actions/checkout@v4
-      with:
-        lfs: 'true'
-
-    - name: Set up
-      uses: actions/setup-go@v4
-      with:
-        go-version: stable
+    - uses: actions/setup-go@v5
+      with: { go-version: stable }
 
     - name: Build
       run: .github/workflows/cross.sh

.github/workflows/go.yml

@@ -1,64 +0,0 @@
-name: Go
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-  workflow_dispatch:
-
-jobs:
-  test:
-    strategy:
-      matrix:
-        os: [macos-latest, ubuntu-latest, windows-latest]
-    runs-on: ${{ matrix.os }}
-
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        lfs: 'true'
-
-    - name: Set up
-      uses: actions/setup-go@v4
-      with:
-        go-version: stable
-
-    - name: Format
-      run: gofmt -s -w . && git diff --exit-code
-      if: matrix.os != 'windows-latest'
-
-    - name: Tidy
-      run: go mod tidy && git diff --exit-code
-
-    - name: Download
-      run: go mod download
-
-    - name: Verify
-      run: go mod verify
-
-    - name: Vet
-      run: go vet ./...
-
-    - name: Build
-      run: go build -v ./...
-
-    - name: Test
-      run: go test -v ./...
-
-    - name: Test no locks
-      run: go test -v -tags sqlite3_nosys ./tests -run TestDB_nolock
-
-    - name: Test BSD locks
-      run: go test -v -tags sqlite3_flock ./...
-      if: matrix.os == 'macos-latest'
-
-    - name: Coverage report
-      uses: ncruces/go-coverage-report@v0
-      with:
-        chart: true
-        amend: true
-        reuse-go: true
-      if: |
-        github.event_name == 'push' &&
-        matrix.os == 'ubuntu-latest'

.github/workflows/repro.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ "$OSTYPE" == "linux"* ]]; then
+  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-22/wasi-sdk-22.0-linux.tar.gz"
+  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_117/binaryen-version_117-x86_64-linux.tar.gz"
+elif [[ "$OSTYPE" == "darwin"* ]]; then
+  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-22/wasi-sdk-22.0-macos.tar.gz"
+  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_117/binaryen-version_117-x86_64-macos.tar.gz"
+elif [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" ]]; then
+  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-22/wasi-sdk-22.0.m-mingw.tar.gz"
+  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_117/binaryen-version_117-x86_64-windows.tar.gz"
+fi
+
+# Download tools
+mkdir -p tools/
+[ -d "tools/wasi-sdk"* ]         || curl -#L "$WASI_SDK" | tar xzC tools &
+[ -d "tools/binaryen-version"* ] || curl -#L "$BINARYEN" | tar xzC tools &
+wait
+
+# 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

@@ -0,0 +1,31 @@
+name: Reproducible build
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  id-token: write
+  attestations: write
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [macos-latest, ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-go@v5
+      with: { go-version: stable }
+
+    - 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

@@ -0,0 +1,174 @@
+name: Test
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  workflow_dispatch:
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        os: [macos-latest, ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-go@v5
+      with: { go-version: stable }
+
+    - name: Git LFS pull
+      uses: ./.github/actions/lfs
+
+    - name: Format
+      run: gofmt -s -w . && git diff --exit-code
+      if: matrix.os != 'windows-latest'
+
+    - name: Tidy
+      run: go mod tidy && git diff --exit-code
+
+    - name: Download
+      run: go mod download
+
+    - name: Verify
+      run: go mod verify
+
+    - name: Vet
+      run: go vet ./...
+
+    - name: Build
+      run: go build -v ./...
+
+    - name: Test
+      run: go test -v ./... -bench . -benchtime=1x
+
+    - name: Test BSD locks
+      run: go test -v -tags sqlite3_flock ./...
+      if: matrix.os == 'macos-latest'
+
+    - name: Test no shared memory
+      run: go test -v -tags sqlite3_noshm ./...
+      if: matrix.os == 'ubuntu-latest'
+
+    - name: Test no locks
+      run: go test -v -tags sqlite3_nosys ./...
+      if: matrix.os == 'ubuntu-latest'
+
+    - name: Test GORM
+      run: gormlite/test.sh
+
+    - uses: ncruces/go-coverage-report@v0
+      with:
+        chart: true
+        amend: true
+      if: |
+        github.event_name == 'push' &&
+        matrix.os == 'ubuntu-latest'
+
+  test-intel:
+    runs-on: macos-13
+    needs: test
+
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-go@v5
+      with: { go-version: stable }
+
+    - name: Git LFS pull
+      uses: ./.github/actions/lfs
+
+    - name: Test
+      run: go test -v ./...
+
+  test-bsd:
+    runs-on: ubuntu-latest
+    needs: test
+
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-go@v5
+      with: { go-version: stable }
+
+    - name: Git LFS pull
+      uses: ./.github/actions/lfs
+
+    - name: Build
+      env:
+        GOOS: freebsd
+        TESTFLAGS: '-test.v'
+      run: .github/workflows/build-test.sh
+
+    - name: Test
+      uses: cross-platform-actions/action@v0.24.0
+      with:
+        operating_system: freebsd
+        version: '14.0'
+        shell: bash
+        run: . ./test.sh
+        sync_files: runner-to-vm
+
+  test-qemu:
+    runs-on: ubuntu-latest
+    needs: test
+
+    steps:
+    - uses: docker/setup-qemu-action@v3
+    - uses: actions/checkout@v4
+    - uses: actions/setup-go@v5
+      with: { go-version: stable }
+
+    - name: Git LFS pull
+      uses: ./.github/actions/lfs
+
+    - name: Test 386 (32-bit)
+      run: GOARCH=386 go test -v -short ./...
+
+    - name: Test arm64 (compiler)
+      run: GOARCH=arm64 go test -v -short ./...
+
+    - name: Test riscv64 (interpreter)
+      run: GOARCH=riscv64 go test -v -short ./...
+
+    - name: Test s390x (big-endian, z/OS demo)
+      run: GOARCH=s390x go test -v -short -tags sqlite3_flock ./...
+
+  test-vm:
+    runs-on: ubuntu-latest
+    needs: test
+
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-go@v5
+      with: { go-version: stable }
+
+    - name: Git LFS pull
+      uses: ./.github/actions/lfs
+
+    - name: Build illumos
+      env:
+        GOOS: illumos
+        TESTFLAGS: '-test.v -test.short'
+      run: .github/workflows/build-test.sh
+
+    - name: Test illumos
+      uses: vmactions/omnios-vm@v1
+      with:
+        usesh: true
+        copyback: false
+        run: . ./test.sh
+
+    - name: Build Solaris
+      env:
+        GOOS: solaris
+        TESTFLAGS: '-test.v -test.short'
+      run: .github/workflows/build-test.sh
+
+    - name: Test Solaris
+      uses: vmactions/solaris-vm@v1
+      with:
+        usesh: true
+        copyback: false
+        run: . ./test.sh
+      continue-on-error: true

README.md

@@ -4,8 +4,15 @@
 [![Go Report](https://goreportcard.com/badge/github.com/ncruces/go-sqlite3)](https://goreportcard.com/report/github.com/ncruces/go-sqlite3)
 [![Go Coverage](https://github.com/ncruces/go-sqlite3/wiki/coverage.svg)](https://github.com/ncruces/go-sqlite3/wiki/Test-coverage-report)
 
-Go module `github.com/ncruces/go-sqlite3` wraps a [WASM](https://webassembly.org/) build of [SQLite](https://sqlite.org/),
-and uses [wazero](https://wazero.io/) to provide `cgo`-free SQLite bindings.
+Go module `github.com/ncruces/go-sqlite3` is a `cgo`-free [SQLite](https://sqlite.org/) wrapper.\
+It provides a [`database/sql`](https://pkg.go.dev/database/sql) compatible driver,
+as well as direct access to most of the [C SQLite API](https://sqlite.org/cintro.html).
+
+It wraps a [Wasm](https://webassembly.org/) [build](embed/) of SQLite,
+and uses [wazero](https://wazero.io/) as the runtime.\
+Go, wazero and [`x/sys`](https://pkg.go.dev/golang.org/x/sys) are the _only_ runtime dependencies [^1].
+
+### Packages
 
 - [`github.com/ncruces/go-sqlite3`](https://pkg.go.dev/github.com/ncruces/go-sqlite3)
   wraps the [C SQLite API](https://sqlite.org/cintro.html)
@@ -20,20 +27,34 @@ and uses [wazero](https://wazero.io/) to provide `cgo`-free SQLite bindings.
 - [`github.com/ncruces/go-sqlite3/gormlite`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/gormlite)
   provides a [GORM](https://gorm.io) driver.
 
-### Loadable extensions
+### Extensions
 
-- [`github.com/ncruces/go-sqlite3/ext/array`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/blob)
+- [`github.com/ncruces/go-sqlite3/ext/array`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/array)
   provides the [`array`](https://sqlite.org/carray.html) table-valued function.
-- [`github.com/ncruces/go-sqlite3/ext/blob`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/blob)
+- [`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)
+  reads, writes and lists files.
+- [`github.com/ncruces/go-sqlite3/ext/hash`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/hash)
+  provides cryptographic hash functions.
 - [`github.com/ncruces/go-sqlite3/ext/lines`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/lines)
-  reads files [line-by-line](https://github.com/asg017/sqlite-lines).
+  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/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 functions](https://www.oreilly.com/library/view/sql-in-a/9780596155322/ch04s02.html).
+  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/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)
@@ -41,64 +62,46 @@ and uses [wazero](https://wazero.io/) to provide `cgo`-free SQLite bindings.
 
 ### Advanced features
 
-- [x] [incremental BLOB I/O](https://sqlite.org/c3ref/blob_open.html)
-- [x] [nested transactions](https://sqlite.org/lang_savepoint.html)
-- [x] [custom functions](https://sqlite.org/c3ref/create_function.html)
-- [x] [virtual tables](https://sqlite.org/vtab.html)
-- [x] [custom VFSes](https://sqlite.org/vfs.html)
-- [x] [online backup](https://sqlite.org/backup.html)
-- [x] [JSON support](https://www.sqlite.org/json1.html)
-- [x] [Unicode support](https://sqlite.org/src/dir/ext/icu)
+- [incremental BLOB I/O](https://sqlite.org/c3ref/blob_open.html)
+- [nested transactions](https://sqlite.org/lang_savepoint.html)
+- [custom functions](https://sqlite.org/c3ref/create_function.html)
+- [virtual tables](https://sqlite.org/vtab.html)
+- [custom VFSes](https://sqlite.org/vfs.html)
+- [online backup](https://sqlite.org/backup.html)
+- [JSON support](https://sqlite.org/json1.html)
+- [math functions](https://sqlite.org/lang_mathfunc.html)
+- [full-text search](https://sqlite.org/fts5.html)
+- [geospatial search](https://sqlite.org/geopoly.html)
+- [encryption at rest](vfs/adiantum/README.md)
+- [and more…](embed/README.md)
 
 ### Caveats
 
 This module replaces the SQLite [OS Interface](https://sqlite.org/vfs.html)
-(aka VFS) with a [pure Go](vfs/) implementation.
-This has benefits, but also comes with some drawbacks.
+(aka VFS) with a [pure Go](vfs/) implementation,
+which has advantages and disadvantages.
 
-#### Write-Ahead Logging
+Read more about the Go VFS design [here](vfs/README.md).
 
-Because WASM does not support shared memory,
-[WAL](https://sqlite.org/wal.html) support is [limited](https://sqlite.org/wal.html#noshm).
+### Testing
 
-To work around this limitation, SQLite is [patched](sqlite3/locking_mode.patch)
-to always use `EXCLUSIVE` locking mode for WAL databases.
+This project aims for [high test coverage](https://github.com/ncruces/go-sqlite3/wiki/Test-coverage-report).
+It also benefits greatly from [SQLite's](https://sqlite.org/testing.html) and
+[wazero's](https://tetrate.io/blog/introducing-wazero-from-tetrate/#:~:text=Rock%2Dsolid%20test%20approach) thorough testing.
 
-Because connection pooling is incompatible with `EXCLUSIVE` locking mode,
-to use the [`database/sql`](https://pkg.go.dev/database/sql) driver
-with WAL mode databases you should disable connection pooling by calling
-[`db.SetMaxOpenConns(1)`](https://pkg.go.dev/database/sql#DB.SetMaxOpenConns).
+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).
 
-#### File Locking
+The Go VFS is tested by running SQLite's
+[mptest](https://github.com/sqlite/sqlite/blob/master/mptest/mptest.c).
 
-POSIX advisory locks, which SQLite uses on Unix, are
-[broken by design](https://sqlite.org/src/artifact/2e8b12?ln=1073-1161).
+### Performance
 
-On Linux, macOS and illumos, this module uses
-[OFD locks](https://www.gnu.org/software/libc/manual/html_node/Open-File-Description-Locks.html)
-to synchronize access to database files.
-OFD locks are fully compatible with POSIX advisory locks.
+Perfomance of the [`database/sql`](https://pkg.go.dev/database/sql) driver is
+[competitive](https://github.com/cvilsmeier/go-sqlite-bench) with alternatives.
 
-On BSD Unixes, this module uses
-[BSD locks](https://man.freebsd.org/cgi/man.cgi?query=flock&sektion=2).
-On BSD Unixes, BSD locks are fully compatible with POSIX advisory locks.
-
-On Windows, this module uses `LockFile`, `LockFileEx`, and `UnlockFile`,
-like SQLite.
-
-On all other platforms, file locking is not supported, and you must use
-[`nolock=1`](https://sqlite.org/uri.html#urinolock)
-to open database files.
-To use the [`database/sql`](https://pkg.go.dev/database/sql) driver
-with `nolock=1` you must disable connection pooling by calling
-[`db.SetMaxOpenConns(1)`](https://pkg.go.dev/database/sql#DB.SetMaxOpenConns).
-
-#### Testing
-
-The pure Go VFS is tested by running SQLite's
-[mptest](https://github.com/sqlite/sqlite/blob/master/mptest/mptest.c)
-on Linux, macOS, Windows and FreeBSD.
-Performance is tested by running
+The Wasm and VFS layers are also tested by running SQLite's
 [speedtest1](https://github.com/sqlite/sqlite/blob/master/test/speedtest1.c).
 
 ### Alternatives
@@ -107,3 +110,6 @@ Performance is tested by running
 - [`crawshaw.io/sqlite`](https://pkg.go.dev/crawshaw.io/sqlite)
 - [`github.com/mattn/go-sqlite3`](https://pkg.go.dev/github.com/mattn/go-sqlite3)
 - [`github.com/zombiezen/go-sqlite`](https://pkg.go.dev/github.com/zombiezen/go-sqlite)
+
+[^1]: anything else you find in `go.mod` is either a test dependency,
+      or needed by one of the extensions.

backup.go

@@ -62,7 +62,7 @@ func (src *Conn) BackupInit(srcDB, dstURI string) (*Backup, error) {
 }
 
 func (c *Conn) backupInit(dst uint32, dstName string, src uint32, srcName string) (*Backup, error) {
-	defer c.arena.reset()
+	defer c.arena.mark()()
 	dstPtr := c.arena.string(dstName)
 	srcPtr := c.arena.string(srcName)
 
@@ -71,12 +71,12 @@ func (c *Conn) backupInit(dst uint32, dstName string, src uint32, srcName string
 		other = src
 	}
 
-	r := c.call(c.api.backupInit,
+	r := c.call("sqlite3_backup_init",
 		uint64(dst), uint64(dstPtr),
 		uint64(src), uint64(srcPtr))
 	if r == 0 {
 		defer c.closeDB(other)
-		r = c.call(c.api.errcode, uint64(dst))
+		r = c.call("sqlite3_errcode", uint64(dst))
 		return nil, c.sqlite.error(r, dst)
 	}
 
@@ -97,7 +97,7 @@ func (b *Backup) Close() error {
 		return nil
 	}
 
-	r := b.c.call(b.c.api.backupFinish, uint64(b.handle))
+	r := b.c.call("sqlite3_backup_finish", uint64(b.handle))
 	b.c.closeDB(b.otherc)
 	b.handle = 0
 	return b.c.error(r)
@@ -108,7 +108,7 @@ func (b *Backup) Close() error {
 //
 // https://sqlite.org/c3ref/backup_finish.html#sqlite3backupstep
 func (b *Backup) Step(nPage int) (done bool, err error) {
-	r := b.c.call(b.c.api.backupStep, uint64(b.handle), uint64(nPage))
+	r := b.c.call("sqlite3_backup_step", uint64(b.handle), uint64(nPage))
 	if r == _DONE {
 		return true, nil
 	}
@@ -120,8 +120,8 @@ func (b *Backup) Step(nPage int) (done bool, err error) {
 //
 // https://sqlite.org/c3ref/backup_finish.html#sqlite3backupremaining
 func (b *Backup) Remaining() int {
-	r := b.c.call(b.c.api.backupRemaining, uint64(b.handle))
-	return int(r)
+	r := b.c.call("sqlite3_backup_remaining", uint64(b.handle))
+	return int(int32(r))
 }
 
 // PageCount returns the total number of pages in the source database
@@ -129,6 +129,6 @@ func (b *Backup) Remaining() int {
 //
 // https://sqlite.org/c3ref/backup_finish.html#sqlite3backuppagecount
 func (b *Backup) PageCount() int {
-	r := b.c.call(b.c.api.backupPageCount, uint64(b.handle))
-	return int(r)
+	r := b.c.call("sqlite3_backup_pagecount", uint64(b.handle))
+	return int(int32(r))
 }

blob.go

@@ -30,7 +30,7 @@ var _ io.ReadWriteSeeker = &Blob{}
 // https://sqlite.org/c3ref/blob_open.html
 func (c *Conn) OpenBlob(db, table, column string, row int64, write bool) (*Blob, error) {
 	c.checkInterrupt()
-	defer c.arena.reset()
+	defer c.arena.mark()()
 	blobPtr := c.arena.new(ptrlen)
 	dbPtr := c.arena.string(db)
 	tablePtr := c.arena.string(table)
@@ -41,7 +41,7 @@ func (c *Conn) OpenBlob(db, table, column string, row int64, write bool) (*Blob,
 		flags = 1
 	}
 
-	r := c.call(c.api.blobOpen, uint64(c.handle),
+	r := c.call("sqlite3_blob_open", uint64(c.handle),
 		uint64(dbPtr), uint64(tablePtr), uint64(columnPtr),
 		uint64(row), flags, uint64(blobPtr))
 
@@ -51,7 +51,7 @@ func (c *Conn) OpenBlob(db, table, column string, row int64, write bool) (*Blob,
 
 	blob := Blob{c: c}
 	blob.handle = util.ReadUint32(c.mod, blobPtr)
-	blob.bytes = int64(c.call(c.api.blobBytes, uint64(blob.handle)))
+	blob.bytes = int64(c.call("sqlite3_blob_bytes", uint64(blob.handle)))
 	return &blob, nil
 }
 
@@ -65,7 +65,7 @@ func (b *Blob) Close() error {
 		return nil
 	}
 
-	r := b.c.call(b.c.api.blobClose, uint64(b.handle))
+	r := b.c.call("sqlite3_blob_close", uint64(b.handle))
 
 	b.handle = 0
 	return b.c.error(r)
@@ -92,10 +92,10 @@ func (b *Blob) Read(p []byte) (n int, err error) {
 		want = avail
 	}
 
-	ptr := b.c.new(uint64(want))
-	defer b.c.free(ptr)
+	defer b.c.arena.mark()()
+	ptr := b.c.arena.new(uint64(want))
 
-	r := b.c.call(b.c.api.blobRead, uint64(b.handle),
+	r := b.c.call("sqlite3_blob_read", uint64(b.handle),
 		uint64(ptr), uint64(want), uint64(b.offset))
 	err = b.c.error(r)
 	if err != nil {
@@ -124,11 +124,11 @@ func (b *Blob) WriteTo(w io.Writer) (n int64, err error) {
 		want = avail
 	}
 
-	ptr := b.c.new(uint64(want))
-	defer b.c.free(ptr)
+	defer b.c.arena.mark()()
+	ptr := b.c.arena.new(uint64(want))
 
 	for want > 0 {
-		r := b.c.call(b.c.api.blobRead, uint64(b.handle),
+		r := b.c.call("sqlite3_blob_read", uint64(b.handle),
 			uint64(ptr), uint64(want), uint64(b.offset))
 		err = b.c.error(r)
 		if err != nil {
@@ -158,10 +158,10 @@ func (b *Blob) WriteTo(w io.Writer) (n int64, err error) {
 //
 // https://sqlite.org/c3ref/blob_write.html
 func (b *Blob) Write(p []byte) (n int, err error) {
-	ptr := b.c.newBytes(p)
-	defer b.c.free(ptr)
+	defer b.c.arena.mark()()
+	ptr := b.c.arena.bytes(p)
 
-	r := b.c.call(b.c.api.blobWrite, uint64(b.handle),
+	r := b.c.call("sqlite3_blob_write", uint64(b.handle),
 		uint64(ptr), uint64(len(p)), uint64(b.offset))
 	err = b.c.error(r)
 	if err != nil {
@@ -187,14 +187,14 @@ func (b *Blob) ReadFrom(r io.Reader) (n int64, err error) {
 		want = 1
 	}
 
-	ptr := b.c.new(uint64(want))
-	defer b.c.free(ptr)
+	defer b.c.arena.mark()()
+	ptr := b.c.arena.new(uint64(want))
 
 	for {
 		mem := util.View(b.c.mod, ptr, uint64(want))
 		m, err := r.Read(mem[:want])
 		if m > 0 {
-			r := b.c.call(b.c.api.blobWrite, uint64(b.handle),
+			r := b.c.call("sqlite3_blob_write", uint64(b.handle),
 				uint64(ptr), uint64(m), uint64(b.offset))
 			err := b.c.error(r)
 			if err != nil {
@@ -243,8 +243,8 @@ func (b *Blob) Seek(offset int64, whence int) (int64, error) {
 //
 // https://sqlite.org/c3ref/blob_reopen.html
 func (b *Blob) Reopen(row int64) error {
-	err := b.c.error(b.c.call(b.c.api.blobReopen, uint64(b.handle), uint64(row)))
-	b.bytes = int64(b.c.call(b.c.api.blobBytes, uint64(b.handle)))
+	err := b.c.error(b.c.call("sqlite3_blob_reopen", uint64(b.handle), uint64(row)))
+	b.bytes = int64(b.c.call("sqlite3_blob_bytes", uint64(b.handle)))
 	b.offset = 0
 	return err
 }

config.go

@@ -0,0 +1,164 @@
+package sqlite3
+
+import (
+	"context"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/tetratelabs/wazero/api"
+)
+
+// Config makes configuration changes to a database connection.
+// Only boolean configuration options are supported.
+// Called with no arg reads the current configuration value,
+// called with one arg sets and returns the new value.
+//
+// https://sqlite.org/c3ref/db_config.html
+func (c *Conn) Config(op DBConfig, arg ...bool) (bool, error) {
+	defer c.arena.mark()()
+	argsPtr := c.arena.new(2 * ptrlen)
+
+	var flag int
+	switch {
+	case len(arg) == 0:
+		flag = -1
+	case arg[0]:
+		flag = 1
+	}
+
+	util.WriteUint32(c.mod, argsPtr+0*ptrlen, uint32(flag))
+	util.WriteUint32(c.mod, argsPtr+1*ptrlen, argsPtr)
+
+	r := c.call("sqlite3_db_config", uint64(c.handle),
+		uint64(op), uint64(argsPtr))
+	return util.ReadUint32(c.mod, argsPtr) != 0, c.error(r)
+}
+
+// ConfigLog sets up the error logging callback for the connection.
+//
+// https://sqlite.org/errlog.html
+func (c *Conn) ConfigLog(cb func(code ExtendedErrorCode, msg string)) error {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	r := c.call("sqlite3_config_log_go", enable)
+	if err := c.error(r); err != nil {
+		return err
+	}
+	c.log = cb
+	return nil
+}
+
+func logCallback(ctx context.Context, mod api.Module, _, iCode, zMsg uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.log != nil {
+		msg := util.ReadString(mod, zMsg, _MAX_LENGTH)
+		c.log(xErrorCode(iCode), msg)
+	}
+}
+
+// Limit allows the size of various constructs to be
+// limited on a connection by connection basis.
+//
+// https://sqlite.org/c3ref/limit.html
+func (c *Conn) Limit(id LimitCategory, value int) int {
+	r := c.call("sqlite3_limit", uint64(c.handle), uint64(id), uint64(value))
+	return int(int32(r))
+}
+
+// SetAuthorizer registers an authorizer callback with the database connection.
+//
+// https://sqlite.org/c3ref/set_authorizer.html
+func (c *Conn) SetAuthorizer(cb func(action AuthorizerActionCode, name3rd, name4th, schema, nameInner string) AuthorizerReturnCode) error {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	r := c.call("sqlite3_set_authorizer_go", uint64(c.handle), enable)
+	if err := c.error(r); err != nil {
+		return err
+	}
+	c.authorizer = cb
+	return nil
+
+}
+
+func authorizerCallback(ctx context.Context, mod api.Module, pDB uint32, action AuthorizerActionCode, zName3rd, zName4th, zSchema, zNameInner uint32) (rc AuthorizerReturnCode) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.authorizer != nil {
+		var name3rd, name4th, schema, nameInner string
+		if zName3rd != 0 {
+			name3rd = util.ReadString(mod, zName3rd, _MAX_NAME)
+		}
+		if zName4th != 0 {
+			name4th = util.ReadString(mod, zName4th, _MAX_NAME)
+		}
+		if zSchema != 0 {
+			schema = util.ReadString(mod, zSchema, _MAX_NAME)
+		}
+		if zNameInner != 0 {
+			nameInner = util.ReadString(mod, zNameInner, _MAX_NAME)
+		}
+		rc = c.authorizer(action, name3rd, name4th, schema, nameInner)
+	}
+	return rc
+}
+
+// WalCheckpoint checkpoints a WAL database.
+//
+// https://sqlite.org/c3ref/wal_checkpoint_v2.html
+func (c *Conn) WalCheckpoint(schema string, mode CheckpointMode) (nLog, nCkpt int, err error) {
+	defer c.arena.mark()()
+	nLogPtr := c.arena.new(ptrlen)
+	nCkptPtr := c.arena.new(ptrlen)
+	schemaPtr := c.arena.string(schema)
+	r := c.call("sqlite3_wal_checkpoint_v2",
+		uint64(c.handle), uint64(schemaPtr), uint64(mode),
+		uint64(nLogPtr), uint64(nCkptPtr))
+	nLog = int(int32(util.ReadUint32(c.mod, nLogPtr)))
+	nCkpt = int(int32(util.ReadUint32(c.mod, nCkptPtr)))
+	return nLog, nCkpt, c.error(r)
+}
+
+// WalAutoCheckpoint configures WAL auto-checkpoints.
+//
+// https://sqlite.org/c3ref/wal_autocheckpoint.html
+func (c *Conn) WalAutoCheckpoint(pages int) error {
+	r := c.call("sqlite3_wal_autocheckpoint", uint64(c.handle), uint64(pages))
+	return c.error(r)
+}
+
+// WalHook registers a callback function to be invoked
+// each time data is committed to a database in WAL mode.
+//
+// https://sqlite.org/c3ref/wal_hook.html
+func (c *Conn) WalHook(cb func(db *Conn, schema string, pages int) error) {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	c.call("sqlite3_wal_hook_go", uint64(c.handle), enable)
+	c.wal = cb
+}
+
+func walCallback(ctx context.Context, mod api.Module, _, pDB, zSchema uint32, pages int32) (rc uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.wal != nil {
+		schema := util.ReadString(mod, zSchema, _MAX_NAME)
+		err := c.wal(c, schema, int(pages))
+		_, rc = errorCode(err, ERROR)
+	}
+	return rc
+}
+
+// AutoVacuumPages registers a autovacuum compaction amount callback.
+//
+// https://sqlite.org/c3ref/autovacuum_pages.html
+func (c *Conn) AutoVacuumPages(cb func(schema string, dbPages, freePages, bytesPerPage uint) uint) error {
+	funcPtr := util.AddHandle(c.ctx, cb)
+	r := c.call("sqlite3_autovacuum_pages_go", uint64(c.handle), uint64(funcPtr))
+	return c.error(r)
+}
+
+func autoVacuumCallback(ctx context.Context, mod api.Module, pApp, zSchema, nDbPage, nFreePage, nBytePerPage uint32) uint32 {
+	fn := util.GetHandle(ctx, pApp).(func(schema string, dbPages, freePages, bytesPerPage uint) uint)
+	schema := util.ReadString(mod, zSchema, _MAX_NAME)
+	return uint32(fn(schema, uint(nDbPage), uint(nFreePage), uint(nBytePerPage)))
+}

conn.go

@@ -2,13 +2,14 @@ package sqlite3
 
 import (
 	"context"
-	"errors"
 	"fmt"
+	"math"
 	"net/url"
-	"runtime"
 	"strings"
+	"time"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/ncruces/go-sqlite3/vfs"
 	"github.com/tetratelabs/wazero/api"
 )
 
@@ -19,9 +20,17 @@ import (
 type Conn struct {
 	*sqlite
 
-	interrupt context.Context
-	pending   *Stmt
-	arena     arena
+	interrupt  context.Context
+	pending    *Stmt
+	busy       func(int) bool
+	log        func(xErrorCode, string)
+	collation  func(*Conn, string)
+	authorizer func(AuthorizerActionCode, string, string, string, string) AuthorizerReturnCode
+	update     func(AuthorizerActionCode, string, string, int64)
+	commit     func() bool
+	rollback   func()
+	wal        func(*Conn, string, int) error
+	arena      arena
 
 	handle uint32
 }
@@ -56,8 +65,6 @@ func newConn(filename string, flags OpenFlag) (conn *Conn, err error) {
 	defer func() {
 		if conn == nil {
 			sqlite.close()
-		} else {
-			runtime.SetFinalizer(conn, util.Finalizer[Conn](3))
 		}
 	}()
 
@@ -72,12 +79,12 @@ func newConn(filename string, flags OpenFlag) (conn *Conn, err error) {
 }
 
 func (c *Conn) openDB(filename string, flags OpenFlag) (uint32, error) {
-	defer c.arena.reset()
+	defer c.arena.mark()()
 	connPtr := c.arena.new(ptrlen)
 	namePtr := c.arena.string(filename)
 
 	flags |= OPEN_EXRESCODE
-	r := c.call(c.api.open, uint64(namePtr), uint64(connPtr), uint64(flags), 0)
+	r := c.call("sqlite3_open_v2", uint64(namePtr), uint64(connPtr), uint64(flags), 0)
 
 	handle := util.ReadUint32(c.mod, connPtr)
 	if err := c.sqlite.error(r, handle); err != nil {
@@ -92,27 +99,25 @@ func (c *Conn) openDB(filename string, flags OpenFlag) (uint32, error) {
 			for _, p := range query["_pragma"] {
 				pragmas.WriteString(`PRAGMA `)
 				pragmas.WriteString(p)
-				pragmas.WriteByte(';')
+				pragmas.WriteString(`;`)
 			}
 		}
-
-		c.arena.reset()
-		pragmaPtr := c.arena.string(pragmas.String())
-		r := c.call(c.api.exec, uint64(handle), uint64(pragmaPtr), 0, 0, 0)
-		if err := c.sqlite.error(r, handle, pragmas.String()); err != nil {
-			if errors.Is(err, ERROR) {
+		if pragmas.Len() != 0 {
+			pragmaPtr := c.arena.string(pragmas.String())
+			r := c.call("sqlite3_exec", uint64(handle), uint64(pragmaPtr), 0, 0, 0)
+			if err := c.sqlite.error(r, handle, pragmas.String()); err != nil {
 				err = fmt.Errorf("sqlite3: invalid _pragma: %w", err)
+				c.closeDB(handle)
+				return 0, err
 			}
-			c.closeDB(handle)
-			return 0, err
 		}
 	}
-
+	c.call("sqlite3_progress_handler_go", uint64(handle), 100)
 	return handle, nil
 }
 
 func (c *Conn) closeDB(handle uint32) {
-	r := c.call(c.api.closeZombie, uint64(handle))
+	r := c.call("sqlite3_close_v2", uint64(handle))
 	if err := c.sqlite.error(r, handle); err != nil {
 		panic(err)
 	}
@@ -135,13 +140,12 @@ func (c *Conn) Close() error {
 	c.pending.Close()
 	c.pending = nil
 
-	r := c.call(c.api.close, uint64(c.handle))
+	r := c.call("sqlite3_close", uint64(c.handle))
 	if err := c.error(r); err != nil {
 		return err
 	}
 
 	c.handle = 0
-	runtime.SetFinalizer(c, nil)
 	return c.close()
 }
 
@@ -151,11 +155,11 @@ func (c *Conn) Close() error {
 // https://sqlite.org/c3ref/exec.html
 func (c *Conn) Exec(sql string) error {
 	c.checkInterrupt()
-	defer c.arena.reset()
+	defer c.arena.mark()()
 	sqlPtr := c.arena.string(sql)
 
-	r := c.call(c.api.exec, uint64(c.handle), uint64(sqlPtr), 0, 0, 0)
-	return c.error(r)
+	r := c.call("sqlite3_exec", uint64(c.handle), uint64(sqlPtr), 0, 0, 0)
+	return c.error(r, sql)
 }
 
 // Prepare calls [Conn.PrepareFlags] with no flags.
@@ -170,26 +174,24 @@ func (c *Conn) Prepare(sql string) (stmt *Stmt, tail string, err error) {
 //
 // https://sqlite.org/c3ref/prepare.html
 func (c *Conn) PrepareFlags(sql string, flags PrepareFlag) (stmt *Stmt, tail string, err error) {
-	if len(sql) > _MAX_LENGTH {
+	if len(sql) > _MAX_SQL_LENGTH {
 		return nil, "", TOOBIG
 	}
-	if emptyStatement(sql) {
-		return nil, "", nil
-	}
 
-	defer c.arena.reset()
+	defer c.arena.mark()()
 	stmtPtr := c.arena.new(ptrlen)
 	tailPtr := c.arena.new(ptrlen)
 	sqlPtr := c.arena.string(sql)
 
-	r := c.call(c.api.prepare, uint64(c.handle),
+	r := c.call("sqlite3_prepare_v3", uint64(c.handle),
 		uint64(sqlPtr), uint64(len(sql)+1), uint64(flags),
 		uint64(stmtPtr), uint64(tailPtr))
 
 	stmt = &Stmt{c: c}
 	stmt.handle = util.ReadUint32(c.mod, stmtPtr)
-	i := util.ReadUint32(c.mod, tailPtr)
-	tail = sql[i-sqlPtr:]
+	if sql := sql[util.ReadUint32(c.mod, tailPtr)-sqlPtr:]; sql != "" {
+		tail = sql
+	}
 
 	if err := c.error(r, sql); err != nil {
 		return nil, "", err
@@ -197,14 +199,54 @@ func (c *Conn) PrepareFlags(sql string, flags PrepareFlag) (stmt *Stmt, tail str
 	if stmt.handle == 0 {
 		return nil, "", nil
 	}
-	return
+	return stmt, tail, nil
+}
+
+// DBName returns the schema name for n-th database on the database connection.
+//
+// https://sqlite.org/c3ref/db_name.html
+func (c *Conn) DBName(n int) string {
+	r := c.call("sqlite3_db_name", uint64(c.handle), uint64(n))
+
+	ptr := uint32(r)
+	if ptr == 0 {
+		return ""
+	}
+	return util.ReadString(c.mod, ptr, _MAX_NAME)
+}
+
+// Filename returns the filename for a database.
+//
+// https://sqlite.org/c3ref/db_filename.html
+func (c *Conn) Filename(schema string) *vfs.Filename {
+	var ptr uint32
+	if schema != "" {
+		defer c.arena.mark()()
+		ptr = c.arena.string(schema)
+	}
+
+	r := c.call("sqlite3_db_filename", uint64(c.handle), uint64(ptr))
+	return vfs.OpenFilename(c.ctx, c.mod, uint32(r), vfs.OPEN_MAIN_DB)
+}
+
+// ReadOnly determines if a database is read-only.
+//
+// https://sqlite.org/c3ref/db_readonly.html
+func (c *Conn) ReadOnly(schema string) (ro bool, ok bool) {
+	var ptr uint32
+	if schema != "" {
+		defer c.arena.mark()()
+		ptr = c.arena.string(schema)
+	}
+	r := c.call("sqlite3_db_readonly", uint64(c.handle), uint64(ptr))
+	return int32(r) > 0, int32(r) < 0
 }
 
 // GetAutocommit tests the connection for auto-commit mode.
 //
 // https://sqlite.org/c3ref/get_autocommit.html
 func (c *Conn) GetAutocommit() bool {
-	r := c.call(c.api.autocommit, uint64(c.handle))
+	r := c.call("sqlite3_get_autocommit", uint64(c.handle))
 	return r != 0
 }
 
@@ -213,20 +255,52 @@ func (c *Conn) GetAutocommit() bool {
 //
 // https://sqlite.org/c3ref/last_insert_rowid.html
 func (c *Conn) LastInsertRowID() int64 {
-	r := c.call(c.api.lastRowid, uint64(c.handle))
+	r := c.call("sqlite3_last_insert_rowid", uint64(c.handle))
 	return int64(r)
 }
 
+// SetLastInsertRowID allows the application to set the value returned by
+// [Conn.LastInsertRowID].
+//
+// https://sqlite.org/c3ref/set_last_insert_rowid.html
+func (c *Conn) SetLastInsertRowID(id int64) {
+	c.call("sqlite3_set_last_insert_rowid", uint64(c.handle), uint64(id))
+}
+
 // Changes returns the number of rows modified, inserted or deleted
 // by the most recently completed INSERT, UPDATE or DELETE statement
 // on the database connection.
 //
 // https://sqlite.org/c3ref/changes.html
 func (c *Conn) Changes() int64 {
-	r := c.call(c.api.changes, uint64(c.handle))
+	r := c.call("sqlite3_changes64", uint64(c.handle))
 	return int64(r)
 }
 
+// TotalChanges returns the number of rows modified, inserted or deleted
+// by all INSERT, UPDATE or DELETE statements completed
+// since the database connection was opened.
+//
+// https://sqlite.org/c3ref/total_changes.html
+func (c *Conn) TotalChanges() int64 {
+	r := c.call("sqlite3_total_changes64", uint64(c.handle))
+	return int64(r)
+}
+
+// ReleaseMemory frees memory used by a database connection.
+//
+// https://sqlite.org/c3ref/db_release_memory.html
+func (c *Conn) ReleaseMemory() error {
+	r := c.call("sqlite3_db_release_memory", uint64(c.handle))
+	return c.error(r)
+}
+
+// GetInterrupt gets the context set with [Conn.SetInterrupt],
+// or nil if none was set.
+func (c *Conn) GetInterrupt() context.Context {
+	return c.interrupt
+}
+
 // SetInterrupt interrupts a long-running query when a context is done.
 //
 // Subsequent uses of the connection will return [INTERRUPT]
@@ -247,57 +321,95 @@ func (c *Conn) SetInterrupt(ctx context.Context) (old context.Context) {
 		return ctx
 	}
 
-	// An uncompleted SQL statement prevents SQLite from ignoring
-	// an interrupt that comes before any other statements are started.
+	// A busy SQL statement prevents SQLite from ignoring an interrupt
+	// that comes before any other statements are started.
 	if c.pending == nil {
-		c.pending, _, _ = c.Prepare(`SELECT 1 UNION ALL SELECT 2`)
-	} else {
-		c.pending.Reset()
+		c.pending, _, _ = c.Prepare(`WITH RECURSIVE c(x) AS (VALUES(0) UNION ALL SELECT x FROM c) SELECT x FROM c`)
 	}
 
 	old = c.interrupt
 	c.interrupt = ctx
-	// Remove the handler if the context can't be canceled.
-	if ctx == nil || ctx.Done() == nil {
-		c.call(c.api.progressHandler, uint64(c.handle), 0)
-		return old
-	}
 
-	c.pending.Step()
-	c.call(c.api.progressHandler, uint64(c.handle), 100)
+	if old != nil && old.Done() != nil && (ctx == nil || ctx.Err() == nil) {
+		c.pending.Reset()
+	}
+	if ctx != nil && ctx.Done() != nil {
+		c.pending.Step()
+	}
 	return old
 }
 
-func progressCallback(ctx context.Context, mod api.Module, _ uint32) uint32 {
-	if c, ok := ctx.Value(connKey{}).(*Conn); ok {
-		if c.interrupt != nil && c.interrupt.Err() != nil {
-			return 1
-		}
-	}
-	return 0
-}
-
 func (c *Conn) checkInterrupt() {
 	if c.interrupt != nil && c.interrupt.Err() != nil {
-		c.call(c.api.interrupt, uint64(c.handle))
+		c.call("sqlite3_interrupt", uint64(c.handle))
 	}
 }
 
-// Pragma executes a PRAGMA statement and returns any results.
-//
-// https://sqlite.org/pragma.html
-func (c *Conn) Pragma(str string) ([]string, error) {
-	stmt, _, err := c.Prepare(`PRAGMA ` + str)
-	if err != nil {
-		return nil, err
+func progressCallback(ctx context.Context, mod api.Module, pDB uint32) (interrupt uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB &&
+		c.interrupt != nil && c.interrupt.Err() != nil {
+		interrupt = 1
 	}
-	defer stmt.Close()
+	return interrupt
+}
 
-	var pragmas []string
-	for stmt.Step() {
-		pragmas = append(pragmas, stmt.ColumnText(0))
+// BusyTimeout sets a busy timeout.
+//
+// https://sqlite.org/c3ref/busy_timeout.html
+func (c *Conn) BusyTimeout(timeout time.Duration) error {
+	ms := min((timeout+time.Millisecond-1)/time.Millisecond, math.MaxInt32)
+	r := c.call("sqlite3_busy_timeout", uint64(c.handle), uint64(ms))
+	return c.error(r)
+}
+
+func timeoutCallback(ctx context.Context, mod api.Module, pDB uint32, count, tmout int32) (retry uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok &&
+		(c.interrupt == nil || c.interrupt.Err() == nil) {
+		const delays = "\x01\x02\x05\x0a\x0f\x14\x19\x19\x19\x32\x32\x64"
+		const totals = "\x00\x01\x03\x08\x12\x21\x35\x4e\x67\x80\xb2\xe4"
+		const ndelay = int32(len(delays) - 1)
+
+		var delay, prior int32
+		if count <= ndelay {
+			delay = int32(delays[count])
+			prior = int32(totals[count])
+		} else {
+			delay = int32(delays[ndelay])
+			prior = int32(totals[ndelay]) + delay*(count-ndelay)
+		}
+
+		if delay = min(delay, tmout-prior); delay > 0 {
+			time.Sleep(time.Duration(delay) * time.Millisecond)
+			retry = 1
+		}
 	}
-	return pragmas, stmt.Close()
+	return retry
+}
+
+// BusyHandler registers a callback to handle [BUSY] errors.
+//
+// https://sqlite.org/c3ref/busy_handler.html
+func (c *Conn) BusyHandler(cb func(count int) (retry bool)) error {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	r := c.call("sqlite3_busy_handler_go", uint64(c.handle), enable)
+	if err := c.error(r); err != nil {
+		return err
+	}
+	c.busy = cb
+	return nil
+}
+
+func busyCallback(ctx context.Context, mod api.Module, pDB uint32, count int32) (retry uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.busy != nil &&
+		(c.interrupt == nil || c.interrupt.Err() == nil) {
+		if c.busy(int(count)) {
+			retry = 1
+		}
+	}
+	return retry
 }
 
 func (c *Conn) error(rc uint64, sql ...string) error {

const.go

@@ -9,10 +9,11 @@ const (
 
 	_UTF8 = 1
 
-	_MAX_NAME            = 512 // Used for short strings: names, error messages…
+	_MAX_NAME            = 1e6 // Self-imposed limit for most NUL terminated strings.
 	_MAX_LENGTH          = 1e9
 	_MAX_SQL_LENGTH      = 1e9
 	_MAX_ALLOCATION_SIZE = 0x7ffffeff
+	_MAX_FUNCTION_ARG    = 100
 
 	ptrlen = 4
 )
@@ -169,16 +170,162 @@ const (
 	PREPARE_NO_VTAB    PrepareFlag = 0x04
 )
 
-// FunctionFlag is a flag that can be passed to [Conn.PrepareFlags].
+// FunctionFlag is a flag that can be passed to
+// [Conn.CreateFunction] and [Conn.CreateWindowFunction].
 //
 // https://sqlite.org/c3ref/c_deterministic.html
 type FunctionFlag uint32
 
 const (
-	DETERMINISTIC FunctionFlag = 0x000000800
-	DIRECTONLY    FunctionFlag = 0x000080000
-	SUBTYPE       FunctionFlag = 0x000100000
-	INNOCUOUS     FunctionFlag = 0x000200000
+	DETERMINISTIC  FunctionFlag = 0x000000800
+	DIRECTONLY     FunctionFlag = 0x000080000
+	SUBTYPE        FunctionFlag = 0x000100000
+	INNOCUOUS      FunctionFlag = 0x000200000
+	RESULT_SUBTYPE FunctionFlag = 0x001000000
+)
+
+// StmtStatus name counter values associated with the [Stmt.Status] method.
+//
+// https://sqlite.org/c3ref/c_stmtstatus_counter.html
+type StmtStatus uint32
+
+const (
+	STMTSTATUS_FULLSCAN_STEP StmtStatus = 1
+	STMTSTATUS_SORT          StmtStatus = 2
+	STMTSTATUS_AUTOINDEX     StmtStatus = 3
+	STMTSTATUS_VM_STEP       StmtStatus = 4
+	STMTSTATUS_REPREPARE     StmtStatus = 5
+	STMTSTATUS_RUN           StmtStatus = 6
+	STMTSTATUS_FILTER_MISS   StmtStatus = 7
+	STMTSTATUS_FILTER_HIT    StmtStatus = 8
+	STMTSTATUS_MEMUSED       StmtStatus = 99
+)
+
+// DBConfig are the available database connection configuration options.
+//
+// https://sqlite.org/c3ref/c_dbconfig_defensive.html
+type DBConfig uint32
+
+const (
+	// DBCONFIG_MAINDBNAME         DBConfig = 1000
+	// DBCONFIG_LOOKASIDE          DBConfig = 1001
+	DBCONFIG_ENABLE_FKEY           DBConfig = 1002
+	DBCONFIG_ENABLE_TRIGGER        DBConfig = 1003
+	DBCONFIG_ENABLE_FTS3_TOKENIZER DBConfig = 1004
+	DBCONFIG_ENABLE_LOAD_EXTENSION DBConfig = 1005
+	DBCONFIG_NO_CKPT_ON_CLOSE      DBConfig = 1006
+	DBCONFIG_ENABLE_QPSG           DBConfig = 1007
+	DBCONFIG_TRIGGER_EQP           DBConfig = 1008
+	DBCONFIG_RESET_DATABASE        DBConfig = 1009
+	DBCONFIG_DEFENSIVE             DBConfig = 1010
+	DBCONFIG_WRITABLE_SCHEMA       DBConfig = 1011
+	DBCONFIG_LEGACY_ALTER_TABLE    DBConfig = 1012
+	DBCONFIG_DQS_DML               DBConfig = 1013
+	DBCONFIG_DQS_DDL               DBConfig = 1014
+	DBCONFIG_ENABLE_VIEW           DBConfig = 1015
+	DBCONFIG_LEGACY_FILE_FORMAT    DBConfig = 1016
+	DBCONFIG_TRUSTED_SCHEMA        DBConfig = 1017
+	DBCONFIG_STMT_SCANSTATUS       DBConfig = 1018
+	DBCONFIG_REVERSE_SCANORDER     DBConfig = 1019
+)
+
+// LimitCategory are the available run-time limit categories.
+//
+// https://sqlite.org/c3ref/c_limit_attached.html
+type LimitCategory uint32
+
+const (
+	LIMIT_LENGTH              LimitCategory = 0
+	LIMIT_SQL_LENGTH          LimitCategory = 1
+	LIMIT_COLUMN              LimitCategory = 2
+	LIMIT_EXPR_DEPTH          LimitCategory = 3
+	LIMIT_COMPOUND_SELECT     LimitCategory = 4
+	LIMIT_VDBE_OP             LimitCategory = 5
+	LIMIT_FUNCTION_ARG        LimitCategory = 6
+	LIMIT_ATTACHED            LimitCategory = 7
+	LIMIT_LIKE_PATTERN_LENGTH LimitCategory = 8
+	LIMIT_VARIABLE_NUMBER     LimitCategory = 9
+	LIMIT_TRIGGER_DEPTH       LimitCategory = 10
+	LIMIT_WORKER_THREADS      LimitCategory = 11
+)
+
+// AuthorizerActionCode are the integer action codes
+// that the authorizer callback may be passed.
+//
+// https://sqlite.org/c3ref/c_alter_table.html
+type AuthorizerActionCode uint32
+
+const (
+	/***************************************************** 3rd ************ 4th ***********/
+	AUTH_CREATE_INDEX        AuthorizerActionCode = 1  /* Index Name      Table Name      */
+	AUTH_CREATE_TABLE        AuthorizerActionCode = 2  /* Table Name      NULL            */
+	AUTH_CREATE_TEMP_INDEX   AuthorizerActionCode = 3  /* Index Name      Table Name      */
+	AUTH_CREATE_TEMP_TABLE   AuthorizerActionCode = 4  /* Table Name      NULL            */
+	AUTH_CREATE_TEMP_TRIGGER AuthorizerActionCode = 5  /* Trigger Name    Table Name      */
+	AUTH_CREATE_TEMP_VIEW    AuthorizerActionCode = 6  /* View Name       NULL            */
+	AUTH_CREATE_TRIGGER      AuthorizerActionCode = 7  /* Trigger Name    Table Name      */
+	AUTH_CREATE_VIEW         AuthorizerActionCode = 8  /* View Name       NULL            */
+	AUTH_DELETE              AuthorizerActionCode = 9  /* Table Name      NULL            */
+	AUTH_DROP_INDEX          AuthorizerActionCode = 10 /* Index Name      Table Name      */
+	AUTH_DROP_TABLE          AuthorizerActionCode = 11 /* Table Name      NULL            */
+	AUTH_DROP_TEMP_INDEX     AuthorizerActionCode = 12 /* Index Name      Table Name      */
+	AUTH_DROP_TEMP_TABLE     AuthorizerActionCode = 13 /* Table Name      NULL            */
+	AUTH_DROP_TEMP_TRIGGER   AuthorizerActionCode = 14 /* Trigger Name    Table Name      */
+	AUTH_DROP_TEMP_VIEW      AuthorizerActionCode = 15 /* View Name       NULL            */
+	AUTH_DROP_TRIGGER        AuthorizerActionCode = 16 /* Trigger Name    Table Name      */
+	AUTH_DROP_VIEW           AuthorizerActionCode = 17 /* View Name       NULL            */
+	AUTH_INSERT              AuthorizerActionCode = 18 /* Table Name      NULL            */
+	AUTH_PRAGMA              AuthorizerActionCode = 19 /* Pragma Name     1st arg or NULL */
+	AUTH_READ                AuthorizerActionCode = 20 /* Table Name      Column Name     */
+	AUTH_SELECT              AuthorizerActionCode = 21 /* NULL            NULL            */
+	AUTH_TRANSACTION         AuthorizerActionCode = 22 /* Operation       NULL            */
+	AUTH_UPDATE              AuthorizerActionCode = 23 /* Table Name      Column Name     */
+	AUTH_ATTACH              AuthorizerActionCode = 24 /* Filename        NULL            */
+	AUTH_DETACH              AuthorizerActionCode = 25 /* Database Name   NULL            */
+	AUTH_ALTER_TABLE         AuthorizerActionCode = 26 /* Database Name   Table Name      */
+	AUTH_REINDEX             AuthorizerActionCode = 27 /* Index Name      NULL            */
+	AUTH_ANALYZE             AuthorizerActionCode = 28 /* Table Name      NULL            */
+	AUTH_CREATE_VTABLE       AuthorizerActionCode = 29 /* Table Name      Module Name     */
+	AUTH_DROP_VTABLE         AuthorizerActionCode = 30 /* Table Name      Module Name     */
+	AUTH_FUNCTION            AuthorizerActionCode = 31 /* NULL            Function Name   */
+	AUTH_SAVEPOINT           AuthorizerActionCode = 32 /* Operation       Savepoint Name  */
+	AUTH_COPY                AuthorizerActionCode = 0  /* No longer used */
+	AUTH_RECURSIVE           AuthorizerActionCode = 33 /* NULL            NULL            */
+)
+
+// AuthorizerReturnCode are the integer codes
+// that the authorizer callback may return.
+//
+// https://sqlite.org/c3ref/c_deny.html
+type AuthorizerReturnCode uint32
+
+const (
+	AUTH_OK     AuthorizerReturnCode = 0
+	AUTH_DENY   AuthorizerReturnCode = 1 /* Abort the SQL statement with an error */
+	AUTH_IGNORE AuthorizerReturnCode = 2 /* Don't allow access, but don't generate an error */
+)
+
+// CheckpointMode are all the checkpoint mode values.
+//
+// https://sqlite.org/c3ref/c_checkpoint_full.html
+type CheckpointMode uint32
+
+const (
+	CHECKPOINT_PASSIVE  CheckpointMode = 0 /* Do as much as possible w/o blocking */
+	CHECKPOINT_FULL     CheckpointMode = 1 /* Wait for writers, then checkpoint */
+	CHECKPOINT_RESTART  CheckpointMode = 2 /* Like FULL but wait for readers */
+	CHECKPOINT_TRUNCATE CheckpointMode = 3 /* Like RESTART but also truncate WAL */
+)
+
+// TxnState are the allowed return values from [Conn.TxnState].
+//
+// https://sqlite.org/c3ref/c_txn_none.html
+type TxnState uint32
+
+const (
+	TXN_NONE  TxnState = 0
+	TXN_READ  TxnState = 1
+	TXN_WRITE TxnState = 2
 )
 
 // Datatype is a fundamental datatype of SQLite.

context.go

@@ -32,14 +32,14 @@ func (ctx Context) Conn() *Conn {
 // https://sqlite.org/c3ref/get_auxdata.html
 func (ctx Context) SetAuxData(n int, data any) {
 	ptr := util.AddHandle(ctx.c.ctx, data)
-	ctx.c.call(ctx.c.api.setAuxData, uint64(ctx.handle), uint64(n), uint64(ptr))
+	ctx.c.call("sqlite3_set_auxdata_go", uint64(ctx.handle), uint64(n), uint64(ptr))
 }
 
 // GetAuxData returns metadata for argument n of the function.
 //
 // https://sqlite.org/c3ref/get_auxdata.html
 func (ctx Context) GetAuxData(n int) any {
-	ptr := uint32(ctx.c.call(ctx.c.api.getAuxData, uint64(ctx.handle), uint64(n)))
+	ptr := uint32(ctx.c.call("sqlite3_get_auxdata", uint64(ctx.handle), uint64(n)))
 	return util.GetHandle(ctx.c.ctx, ptr)
 }
 
@@ -67,7 +67,7 @@ func (ctx Context) ResultInt(value int) {
 //
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultInt64(value int64) {
-	ctx.c.call(ctx.c.api.resultInteger,
+	ctx.c.call("sqlite3_result_int64",
 		uint64(ctx.handle), uint64(value))
 }
 
@@ -75,7 +75,7 @@ func (ctx Context) ResultInt64(value int64) {
 //
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultFloat(value float64) {
-	ctx.c.call(ctx.c.api.resultFloat,
+	ctx.c.call("sqlite3_result_double",
 		uint64(ctx.handle), math.Float64bits(value))
 }
 
@@ -84,9 +84,9 @@ func (ctx Context) ResultFloat(value float64) {
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultText(value string) {
 	ptr := ctx.c.newString(value)
-	ctx.c.call(ctx.c.api.resultText,
+	ctx.c.call("sqlite3_result_text64",
 		uint64(ctx.handle), uint64(ptr), uint64(len(value)),
-		uint64(ctx.c.api.destructor), _UTF8)
+		uint64(ctx.c.freer), _UTF8)
 }
 
 // ResultRawText sets the text result of the function to a []byte.
@@ -94,9 +94,9 @@ func (ctx Context) ResultText(value string) {
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultRawText(value []byte) {
 	ptr := ctx.c.newBytes(value)
-	ctx.c.call(ctx.c.api.resultText,
+	ctx.c.call("sqlite3_result_text64",
 		uint64(ctx.handle), uint64(ptr), uint64(len(value)),
-		uint64(ctx.c.api.destructor), _UTF8)
+		uint64(ctx.c.freer), _UTF8)
 }
 
 // ResultBlob sets the result of the function to a []byte.
@@ -105,16 +105,16 @@ func (ctx Context) ResultRawText(value []byte) {
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultBlob(value []byte) {
 	ptr := ctx.c.newBytes(value)
-	ctx.c.call(ctx.c.api.resultBlob,
+	ctx.c.call("sqlite3_result_blob64",
 		uint64(ctx.handle), uint64(ptr), uint64(len(value)),
-		uint64(ctx.c.api.destructor))
+		uint64(ctx.c.freer))
 }
 
 // ResultZeroBlob sets the result of the function to a zero-filled, length n BLOB.
 //
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultZeroBlob(n int64) {
-	ctx.c.call(ctx.c.api.resultZeroBlob,
+	ctx.c.call("sqlite3_result_zeroblob64",
 		uint64(ctx.handle), uint64(n))
 }
 
@@ -122,7 +122,7 @@ func (ctx Context) ResultZeroBlob(n int64) {
 //
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultNull() {
-	ctx.c.call(ctx.c.api.resultNull,
+	ctx.c.call("sqlite3_result_null",
 		uint64(ctx.handle))
 }
 
@@ -153,9 +153,9 @@ func (ctx Context) resultRFC3339Nano(value time.Time) {
 	buf := util.View(ctx.c.mod, ptr, maxlen)
 	buf = value.AppendFormat(buf[:0], time.RFC3339Nano)
 
-	ctx.c.call(ctx.c.api.resultText,
+	ctx.c.call("sqlite3_result_text64",
 		uint64(ctx.handle), uint64(ptr), uint64(len(buf)),
-		uint64(ctx.c.api.destructor), _UTF8)
+		uint64(ctx.c.freer), _UTF8)
 }
 
 // ResultPointer sets the result of the function to NULL, just like [Context.ResultNull],
@@ -165,7 +165,7 @@ func (ctx Context) resultRFC3339Nano(value time.Time) {
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultPointer(ptr any) {
 	valPtr := util.AddHandle(ctx.c.ctx, ptr)
-	ctx.c.call(ctx.c.api.resultPointer, uint64(valPtr))
+	ctx.c.call("sqlite3_result_pointer_go", uint64(valPtr))
 }
 
 // ResultJSON sets the result of the function to the JSON encoding of value.
@@ -175,6 +175,7 @@ func (ctx Context) ResultJSON(value any) {
 	data, err := json.Marshal(value)
 	if err != nil {
 		ctx.ResultError(err)
+		return
 	}
 	ctx.ResultRawText(data)
 }
@@ -183,10 +184,11 @@ func (ctx Context) ResultJSON(value any) {
 //
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultValue(value Value) {
-	if value.sqlite != ctx.c.sqlite {
+	if value.c != ctx.c {
 		ctx.ResultError(MISUSE)
+		return
 	}
-	ctx.c.call(ctx.c.api.resultValue,
+	ctx.c.call("sqlite3_result_value",
 		uint64(ctx.handle), uint64(value.handle))
 }
 
@@ -195,24 +197,33 @@ func (ctx Context) ResultValue(value Value) {
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultError(err error) {
 	if errors.Is(err, NOMEM) {
-		ctx.c.call(ctx.c.api.resultErrorMem, uint64(ctx.handle))
+		ctx.c.call("sqlite3_result_error_nomem", uint64(ctx.handle))
 		return
 	}
 
 	if errors.Is(err, TOOBIG) {
-		ctx.c.call(ctx.c.api.resultErrorBig, uint64(ctx.handle))
+		ctx.c.call("sqlite3_result_error_toobig", uint64(ctx.handle))
 		return
 	}
 
 	msg, code := errorCode(err, _OK)
 	if msg != "" {
-		ptr := ctx.c.newString(msg)
-		ctx.c.call(ctx.c.api.resultError,
+		defer ctx.c.arena.mark()()
+		ptr := ctx.c.arena.string(msg)
+		ctx.c.call("sqlite3_result_error",
 			uint64(ctx.handle), uint64(ptr), uint64(len(msg)))
-		ctx.c.free(ptr)
 	}
 	if code != _OK {
-		ctx.c.call(ctx.c.api.resultErrorCode,
+		ctx.c.call("sqlite3_result_error_code",
 			uint64(ctx.handle), uint64(code))
 	}
 }
+
+// VTabNoChange may return true if a column is being fetched as part
+// of an update during which the column value will not change.
+//
+// https://sqlite.org/c3ref/vtab_nochange.html
+func (ctx Context) VTabNoChange() bool {
+	r := ctx.c.call("sqlite3_vtab_nochange", uint64(ctx.handle))
+	return r != 0
+}

driver/driver.go

@@ -12,6 +12,18 @@
 //
 //	sql.Open("sqlite3", "file:demo.db?_txlock=immediate")
 //
+// Possible values are: "deferred", "immediate", "exclusive".
+// A [read-only] transaction is always "deferred", regardless of "_txlock".
+//
+// The time encoding/decoding format can be specified using "_timefmt":
+//
+//	sql.Open("sqlite3", "file:demo.db?_timefmt=sqlite")
+//
+// Possible values are: "auto" (the default), "sqlite", "rfc3339";
+// "auto" encodes as RFC 3339 and decodes any [format] supported by SQLite;
+// "sqlite" encodes as SQLite and decodes any [format] supported by SQLite;
+// "rfc3339" encodes and decodes RFC 3339 only.
+//
 // [PRAGMA] statements can be specified using "_pragma":
 //
 //	sql.Open("sqlite3", "file:demo.db?_pragma=busy_timeout(10000)")
@@ -23,7 +35,9 @@
 //
 // [URI]: https://sqlite.org/uri.html
 // [PRAGMA]: https://sqlite.org/pragma.html
+// [format]: https://sqlite.org/lang_datefunc.html#time_values
 // [TRANSACTION]: https://sqlite.org/lang_transaction.html#deferred_immediate_and_exclusive_transactions
+// [read-only]: https://pkg.go.dev/database/sql#TxOptions
 package driver
 
 import (
@@ -36,6 +50,7 @@ import (
 	"net/url"
 	"strings"
 	"time"
+	"unsafe"
 
 	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/internal/util"
@@ -43,70 +58,112 @@ import (
 
 // This variable can be replaced with -ldflags:
 //
-//	go build -ldflags="-X github.com/ncruces/go-sqlite3.driverName=sqlite"
+//	go build -ldflags="-X github.com/ncruces/go-sqlite3/driver.driverName=sqlite"
 var driverName = "sqlite3"
 
 func init() {
 	if driverName != "" {
-		sql.Register(driverName, sqlite{})
+		sql.Register(driverName, &SQLite{})
 	}
 }
 
 // Open opens the SQLite database specified by dataSourceName as a [database/sql.DB].
 //
 // The init function is called by the driver on new connections.
-// The conn can be used to execute queries, register functions, etc.
-// Any error return closes the conn and passes the error to [database/sql].
+// The [sqlite3.Conn] can be used to execute queries, register functions, etc.
+// Any error returned closes the connection and is returned to [database/sql].
 func Open(dataSourceName string, init func(*sqlite3.Conn) error) (*sql.DB, error) {
-	c, err := newConnector(dataSourceName, init)
+	c, err := (&SQLite{Init: init}).OpenConnector(dataSourceName)
 	if err != nil {
 		return nil, err
 	}
 	return sql.OpenDB(c), nil
 }
 
-type sqlite struct{}
+// SQLite implements [database/sql/driver.Driver].
+type SQLite struct {
+	// Init function is called by the driver on new connections.
+	// The [sqlite3.Conn] can be used to execute queries, register functions, etc.
+	// Any error returned closes the connection and is returned to [database/sql].
+	Init func(*sqlite3.Conn) error
+}
 
-func (sqlite) Open(name string) (driver.Conn, error) {
-	c, err := newConnector(name, nil)
+// Open implements [database/sql/driver.Driver].
+func (d *SQLite) Open(name string) (driver.Conn, error) {
+	c, err := d.newConnector(name)
 	if err != nil {
 		return nil, err
 	}
 	return c.Connect(context.Background())
 }
 
-func (sqlite) OpenConnector(name string) (driver.Connector, error) {
-	return newConnector(name, nil)
+// OpenConnector implements [database/sql/driver.DriverContext].
+func (d *SQLite) OpenConnector(name string) (driver.Connector, error) {
+	return d.newConnector(name)
 }
 
-func newConnector(name string, init func(*sqlite3.Conn) error) (*connector, error) {
-	c := connector{name: name, init: init}
+func (d *SQLite) newConnector(name string) (*connector, error) {
+	c := connector{driver: d, name: name}
+
+	var txlock, timefmt string
 	if strings.HasPrefix(name, "file:") {
 		if _, after, ok := strings.Cut(name, "?"); ok {
 			query, err := url.ParseQuery(after)
 			if err != nil {
 				return nil, err
 			}
-			c.txlock = query.Get("_txlock")
-			c.pragmas = len(query["_pragma"]) > 0
+			txlock = query.Get("_txlock")
+			timefmt = query.Get("_timefmt")
+			c.pragmas = query.Has("_pragma")
 		}
 	}
+
+	switch txlock {
+	case "":
+		c.txBegin = "BEGIN"
+	case "deferred", "immediate", "exclusive":
+		c.txBegin = "BEGIN " + txlock
+	default:
+		return nil, fmt.Errorf("sqlite3: invalid _txlock: %s", txlock)
+	}
+
+	switch timefmt {
+	case "":
+		c.tmRead = sqlite3.TimeFormatAuto
+		c.tmWrite = sqlite3.TimeFormatDefault
+	case "sqlite":
+		c.tmRead = sqlite3.TimeFormatAuto
+		c.tmWrite = sqlite3.TimeFormat3
+	case "rfc3339":
+		c.tmRead = sqlite3.TimeFormatDefault
+		c.tmWrite = sqlite3.TimeFormatDefault
+	default:
+		c.tmRead = sqlite3.TimeFormat(timefmt)
+		c.tmWrite = sqlite3.TimeFormat(timefmt)
+	}
 	return &c, nil
 }
 
 type connector struct {
-	init    func(*sqlite3.Conn) error
+	driver  *SQLite
 	name    string
-	txlock  string
+	txBegin string
+	tmRead  sqlite3.TimeFormat
+	tmWrite sqlite3.TimeFormat
 	pragmas bool
 }
 
 func (n *connector) Driver() driver.Driver {
-	return sqlite{}
+	return n.driver
 }
 
 func (n *connector) Connect(ctx context.Context) (_ driver.Conn, err error) {
-	var c conn
+	c := &conn{
+		txBegin: n.txBegin,
+		tmRead:  n.tmRead,
+		tmWrite: n.tmWrite,
+	}
+
 	c.Conn, err = sqlite3.Open(n.name)
 	if err != nil {
 		return nil, err
@@ -120,27 +177,19 @@ func (n *connector) Connect(ctx context.Context) (_ driver.Conn, err error) {
 	old := c.Conn.SetInterrupt(ctx)
 	defer c.Conn.SetInterrupt(old)
 
-	switch n.txlock {
-	case "":
-		c.txBegin = "BEGIN"
-	case "deferred", "immediate", "exclusive":
-		c.txBegin = "BEGIN " + n.txlock
-	default:
-		return nil, fmt.Errorf("sqlite3: invalid _txlock: %s", n.txlock)
-	}
 	if !n.pragmas {
-		err = c.Conn.Exec(`PRAGMA busy_timeout=60000`)
+		err = c.Conn.BusyTimeout(60 * time.Second)
 		if err != nil {
 			return nil, err
 		}
 	}
-	if n.init != nil {
-		err = n.init(c.Conn)
+	if n.driver.Init != nil {
+		err = n.driver.Init(c.Conn)
 		if err != nil {
 			return nil, err
 		}
 	}
-	if n.pragmas || n.init != nil {
+	if n.pragmas || n.driver.Init != nil {
 		s, _, err := c.Conn.Prepare(`PRAGMA query_only`)
 		if err != nil {
 			return nil, err
@@ -155,7 +204,7 @@ func (n *connector) Connect(ctx context.Context) (_ driver.Conn, err error) {
 			return nil, err
 		}
 	}
-	return &c, nil
+	return c, nil
 }
 
 type conn struct {
@@ -163,6 +212,8 @@ type conn struct {
 	txBegin    string
 	txCommit   string
 	txRollback string
+	tmRead     sqlite3.TimeFormat
+	tmWrite    sqlite3.TimeFormat
 	readOnly   byte
 }
 
@@ -178,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{})
 }
@@ -247,19 +299,10 @@ func (c *conn) PrepareContext(ctx context.Context, query string) (driver.Stmt, e
 		return nil, err
 	}
 	if tail != "" {
-		// Check if the tail contains any SQL.
-		st, _, err := c.Conn.Prepare(tail)
-		if err != nil {
-			s.Close()
-			return nil, err
-		}
-		if st != nil {
-			s.Close()
-			st.Close()
-			return nil, util.TailErr
-		}
+		s.Close()
+		return nil, util.TailErr
 	}
-	return &stmt{s, c.Conn}, 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) {
@@ -270,7 +313,7 @@ func (c *conn) ExecContext(ctx context.Context, query string, args []driver.Name
 
 	if savept, ok := ctx.(*saveptCtx); ok {
 		// Called from driver.Savepoint.
-		savept.Savepoint = c.Savepoint()
+		savept.Savepoint = c.Conn.Savepoint()
 		return resultRowsAffected(0), nil
 	}
 
@@ -285,13 +328,15 @@ func (c *conn) ExecContext(ctx context.Context, query string, args []driver.Name
 	return newResult(c.Conn), nil
 }
 
-func (*conn) CheckNamedValue(arg *driver.NamedValue) error {
+func (c *conn) CheckNamedValue(arg *driver.NamedValue) error {
 	return nil
 }
 
 type stmt struct {
-	Stmt *sqlite3.Stmt
-	Conn *sqlite3.Conn
+	*sqlite3.Stmt
+	tmWrite sqlite3.TimeFormat
+	tmRead  sqlite3.TimeFormat
+	inputs  int
 }
 
 var (
@@ -301,17 +346,18 @@ var (
 	_ driver.NamedValueChecker = &stmt{}
 )
 
-func (s *stmt) Close() error {
-	return s.Stmt.Close()
-}
-
 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
 }
 
@@ -331,15 +377,15 @@ func (s *stmt) ExecContext(ctx context.Context, args []driver.NamedValue) (drive
 		return nil, err
 	}
 
-	old := s.Conn.SetInterrupt(ctx)
-	defer s.Conn.SetInterrupt(old)
+	old := s.Stmt.Conn().SetInterrupt(ctx)
+	defer s.Stmt.Conn().SetInterrupt(old)
 
 	err = s.Stmt.Exec()
 	if err != nil {
 		return nil, err
 	}
 
-	return newResult(s.Conn), nil
+	return newResult(s.Stmt.Conn()), nil
 }
 
 func (s *stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
@@ -347,15 +393,10 @@ func (s *stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driv
 	if err != nil {
 		return nil, err
 	}
-	return &rows{ctx, s.Stmt, s.Conn}, nil
+	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]
@@ -386,11 +427,11 @@ func (s *stmt) setupBindings(args []driver.NamedValue) error {
 			case sqlite3.ZeroBlob:
 				err = s.Stmt.BindZeroBlob(id, int64(a))
 			case time.Time:
-				err = s.Stmt.BindTime(id, a, sqlite3.TimeFormatDefault)
-			case interface{ Pointer() any }:
-				err = s.Stmt.BindPointer(id, a.Pointer())
-			case interface{ JSON() any }:
-				err = s.Stmt.BindJSON(id, a.JSON())
+				err = s.Stmt.BindTime(id, a, s.tmWrite)
+			case util.JSON:
+				err = s.Stmt.BindJSON(id, a.Value)
+			case util.PointerUnwrap:
+				err = s.Stmt.BindPointer(id, util.UnwrapPointer(a))
 			case nil:
 				err = s.Stmt.BindNull(id)
 			default:
@@ -407,9 +448,8 @@ func (s *stmt) setupBindings(args []driver.NamedValue) error {
 func (s *stmt) CheckNamedValue(arg *driver.NamedValue) error {
 	switch arg.Value.(type) {
 	case bool, int, int64, float64, string, []byte,
-		sqlite3.ZeroBlob, time.Time,
-		interface{ Pointer() any },
-		interface{ JSON() any },
+		time.Time, sqlite3.ZeroBlob,
+		util.JSON, util.PointerUnwrap,
 		nil:
 		return nil
 	default:
@@ -449,27 +489,52 @@ func (r resultRowsAffected) RowsAffected() (int64, error) {
 }
 
 type rows struct {
-	ctx  context.Context
-	Stmt *sqlite3.Stmt
-	Conn *sqlite3.Conn
+	ctx context.Context
+	*stmt
+	names []string
+	types []string
 }
 
 func (r *rows) Close() error {
+	r.Stmt.ClearBindings()
 	return r.Stmt.Reset()
 }
 
 func (r *rows) Columns() []string {
-	count := r.Stmt.ColumnCount()
-	columns := make([]string, count)
-	for i := range columns {
-		columns[i] = r.Stmt.ColumnName(i)
+	if r.names == nil {
+		count := r.Stmt.ColumnCount()
+		r.names = make([]string, count)
+		for i := range r.names {
+			r.names[i] = r.Stmt.ColumnName(i)
+		}
 	}
-	return columns
+	return r.names
+}
+
+func (r *rows) declType(index int) string {
+	if r.types == nil {
+		count := r.Stmt.ColumnCount()
+		r.types = make([]string, count)
+		for i := range r.types {
+			r.types[i] = strings.ToUpper(r.Stmt.ColumnDeclType(i))
+		}
+	}
+	return r.types[index]
+}
+
+func (r *rows) ColumnTypeDatabaseTypeName(index int) string {
+	decltype := r.declType(index)
+	if len := len(decltype); len > 0 && decltype[len-1] == ')' {
+		if i := strings.LastIndexByte(decltype, '('); i >= 0 {
+			decltype = decltype[:i]
+		}
+	}
+	return strings.TrimSpace(decltype)
 }
 
 func (r *rows) Next(dest []driver.Value) error {
-	old := r.Conn.SetInterrupt(r.ctx)
-	defer r.Conn.SetInterrupt(old)
+	old := r.Stmt.Conn().SetInterrupt(r.ctx)
+	defer r.Stmt.Conn().SetInterrupt(old)
 
 	if !r.Stmt.Step() {
 		if err := r.Stmt.Err(); err != nil {
@@ -478,22 +543,40 @@ func (r *rows) Next(dest []driver.Value) error {
 		return io.EOF
 	}
 
+	data := unsafe.Slice((*any)(unsafe.SliceData(dest)), len(dest))
+	err := r.Stmt.Columns(data)
 	for i := range dest {
-		switch r.Stmt.ColumnType(i) {
-		case sqlite3.INTEGER:
-			dest[i] = r.Stmt.ColumnInt64(i)
-		case sqlite3.FLOAT:
-			dest[i] = r.Stmt.ColumnFloat(i)
-		case sqlite3.BLOB:
-			dest[i] = r.Stmt.ColumnRawBlob(i)
-		case sqlite3.TEXT:
-			dest[i] = stringOrTime(r.Stmt.ColumnRawText(i))
-		case sqlite3.NULL:
-			dest[i] = nil
-		default:
-			panic(util.AssertErr())
+		if t, ok := r.decodeTime(i, dest[i]); ok {
+			dest[i] = t
+			continue
+		}
+		if s, ok := dest[i].(string); ok {
+			t, ok := maybeTime(s)
+			if ok {
+				dest[i] = t
+			}
 		}
 	}
-
-	return r.Stmt.Err()
+	return err
+}
+
+func (r *rows) decodeTime(i int, v any) (_ time.Time, ok bool) {
+	if r.tmRead == sqlite3.TimeFormatDefault {
+		// handled by maybeTime
+		return
+	}
+	switch v.(type) {
+	case int64, float64, string:
+		// could be a time value
+	default:
+		return
+	}
+	switch r.declType(i) {
+	case "DATE", "TIME", "DATETIME", "TIMESTAMP":
+		// could be a time value
+	default:
+		return
+	}
+	t, err := r.tmRead.Decode(v)
+	return t, err == nil
 }

driver/driver_test.go

@@ -6,13 +6,16 @@ import (
 	"database/sql"
 	"errors"
 	"math"
+	"net/url"
 	"path/filepath"
 	"testing"
 	"time"
 
 	"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/vfs"
 )
 
 func Test_Open_dir(t *testing.T) {
@@ -78,6 +81,9 @@ func Test_Open_pragma_invalid(t *testing.T) {
 }
 
 func Test_Open_txLock(t *testing.T) {
+	if !vfs.SupportsFileLocking {
+		t.Skip("skipping without locks")
+	}
 	t.Parallel()
 
 	db, err := sql.Open("sqlite3", "file:"+
@@ -114,13 +120,7 @@ func Test_Open_txLock(t *testing.T) {
 func Test_Open_txLock_invalid(t *testing.T) {
 	t.Parallel()
 
-	db, err := sql.Open("sqlite3", "file::memory:?_txlock=xclusive")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db.Close()
-
-	_, err = db.Conn(context.TODO())
+	_, err := sql.Open("sqlite3", "file::memory:?_txlock=xclusive")
 	if err == nil {
 		t.Fatal("want error")
 	}
@@ -130,6 +130,9 @@ func Test_Open_txLock_invalid(t *testing.T) {
 }
 
 func Test_BeginTx(t *testing.T) {
+	if !vfs.SupportsFileLocking {
+		t.Skip("skipping without locks")
+	}
 	t.Parallel()
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -158,7 +161,7 @@ func Test_BeginTx(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	_, err = tx1.Exec(`CREATE TABLE IF NOT EXISTS test (col)`)
+	_, err = tx1.Exec(`CREATE TABLE test (col)`)
 	if err == nil {
 		t.Error("want error")
 	}
@@ -186,12 +189,6 @@ func Test_Prepare(t *testing.T) {
 	}
 	defer db.Close()
 
-	stmt, err := db.Prepare(`SELECT 1; -- HERE`)
-	if err != nil {
-		t.Error(err)
-	}
-	defer stmt.Close()
-
 	var serr *sqlite3.Error
 	_, err = db.Prepare(`SELECT`)
 	if err == nil {
@@ -207,18 +204,14 @@ func Test_Prepare(t *testing.T) {
 		t.Error("got message:", got)
 	}
 
+	_, err = db.Prepare(`SELECT 1; `)
+	if err.Error() != string(util.TailErr) {
+		t.Error("want tailErr")
+	}
+
 	_, err = db.Prepare(`SELECT 1; SELECT`)
-	if err == nil {
-		t.Error("want error")
-	}
-	if !errors.As(err, &serr) {
-		t.Fatalf("got %T, want sqlite3.Error", err)
-	}
-	if rc := serr.Code(); rc != sqlite3.ERROR {
-		t.Errorf("got %d, want sqlite3.ERROR", rc)
-	}
-	if got := err.Error(); got != `sqlite3: SQL logic error: incomplete input` {
-		t.Error("got message:", got)
+	if err.Error() != string(util.TailErr) {
+		t.Error("want tailErr")
 	}
 
 	_, err = db.Prepare(`SELECT 1; SELECT 2`)
@@ -311,3 +304,39 @@ func Test_QueryRow_blob_null(t *testing.T) {
 		}
 	}
 }
+
+func Test_time(t *testing.T) {
+	t.Parallel()
+
+	for _, fmt := range []string{"auto", "sqlite", "rfc3339", time.ANSIC} {
+		t.Run(fmt, func(t *testing.T) {
+			db, err := sql.Open("sqlite3", "file::memory:?_timefmt="+url.QueryEscape(fmt))
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer db.Close()
+
+			twosday := time.Date(2022, 2, 22, 22, 22, 22, 0, time.UTC)
+
+			_, err = db.Exec(`CREATE TABLE test (at DATETIME)`)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			_, err = db.Exec(`INSERT INTO test VALUES (?)`, twosday)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			var got time.Time
+			err = db.QueryRow(`SELECT * FROM test`).Scan(&got)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if !got.Equal(twosday) {
+				t.Errorf("got: %v", got)
+			}
+		})
+	}
+}

driver/example_test.go

@@ -1,3 +1,5 @@
+//go:build (linux || darwin || windows || freebsd || illumos) && !sqlite3_nosys
+
 package driver_test
 
 // Adapted from: https://go.dev/doc/tutorial/database-access

driver/json_test.go

@@ -18,7 +18,7 @@ func Example_json() {
 	defer db.Close()
 
 	_, err = db.Exec(`
-		CREATE TABLE IF NOT EXISTS orders (
+		CREATE TABLE orders (
 			cart_id INTEGER PRIMARY KEY,
 			user_id INTEGER NOT NULL,
 			cart    TEXT

driver/savepoint_test.go

@@ -16,7 +16,7 @@ func ExampleSavepoint() {
 	}
 	defer db.Close()
 
-	_, err = db.Exec(`CREATE TABLE IF NOT EXISTS users (id INT, name VARCHAR(10))`)
+	_, err = db.Exec(`CREATE TABLE users (id INT, name VARCHAR(10))`)
 	if err != nil {
 		log.Fatal(err)
 	}

driver/time.go

@@ -1,7 +1,6 @@
 package driver
 
 import (
-	"database/sql/driver"
 	"time"
 )
 
@@ -9,23 +8,24 @@ import (
 // if it roundtrips back to the same string.
 // This way times can be persisted to, and recovered from, the database,
 // but if a string is needed, [database/sql] will recover the same string.
-func stringOrTime(text []byte) driver.Value {
+func maybeTime(text string) (_ time.Time, _ bool) {
 	// Weed out (some) values that can't possibly be
 	// [time.RFC3339Nano] timestamps.
 	if len(text) < len("2006-01-02T15:04:05Z") {
-		return string(text)
+		return
 	}
 	if len(text) > len(time.RFC3339Nano) {
-		return string(text)
+		return
 	}
 	if text[4] != '-' || text[10] != 'T' || text[16] != ':' {
-		return string(text)
+		return
 	}
 
 	// Slow path.
-	date, err := time.Parse(time.RFC3339Nano, string(text))
-	if err == nil && date.Format(time.RFC3339Nano) == string(text) {
-		return date
+	var buf [len(time.RFC3339Nano)]byte
+	date, err := time.Parse(time.RFC3339Nano, text)
+	if err == nil && text == string(date.AppendFormat(buf[:0], time.RFC3339Nano)) {
+		return date, true
 	}
-	return string(text)
+	return
 }

driver/time_test.go

@@ -22,26 +22,18 @@ func Fuzz_stringOrTime_1(f *testing.F) {
 	f.Add("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.")
 
 	f.Fuzz(func(t *testing.T, str string) {
-		value := stringOrTime([]byte(str))
-
-		switch v := value.(type) {
-		case time.Time:
+		v, ok := maybeTime(str)
+		if ok {
 			// Make sure times round-trip to the same string:
 			// https://pkg.go.dev/database/sql#Rows.Scan
 			if v.Format(time.RFC3339Nano) != str {
 				t.Fatalf("did not round-trip: %q", str)
 			}
-		case string:
-			if v != str {
-				t.Fatalf("did not round-trip: %q", str)
-			}
-
+		} else {
 			date, err := time.Parse(time.RFC3339Nano, str)
 			if err == nil && date.Format(time.RFC3339Nano) == str {
 				t.Fatalf("would round-trip: %q", str)
 			}
-		default:
-			t.Fatalf("invalid type %T: %q", v, str)
 		}
 	})
 }
@@ -49,38 +41,34 @@ func Fuzz_stringOrTime_1(f *testing.F) {
 // This checks that any [time.Time] can be recovered as a [time.Time],
 // with nanosecond accuracy, and preserving any timezone offset.
 func Fuzz_stringOrTime_2(f *testing.F) {
-	f.Add(0, 0)
-	f.Add(0, 1)
-	f.Add(0, -1)
-	f.Add(0, 999_999_999)
-	f.Add(0, 1_000_000_000)
-	f.Add(7956915742, 222_222_222)    // twosday
-	f.Add(639095955742, 222_222_222)  // twosday, year 22222AD
-	f.Add(-763421161058, 222_222_222) // twosday, year 22222BC
+	f.Add(int64(0), int64(0))
+	f.Add(int64(0), int64(1))
+	f.Add(int64(0), int64(-1))
+	f.Add(int64(0), int64(999_999_999))
+	f.Add(int64(0), int64(1_000_000_000))
+	f.Add(int64(7956915742), int64(222_222_222))    // twosday
+	f.Add(int64(639095955742), int64(222_222_222))  // twosday, year 22222AD
+	f.Add(int64(-763421161058), int64(222_222_222)) // twosday, year 22222BC
 
 	checkTime := func(t testing.TB, date time.Time) {
-		value := stringOrTime([]byte(date.Format(time.RFC3339Nano)))
-
-		switch v := value.(type) {
-		case time.Time:
+		v, ok := maybeTime(date.Format(time.RFC3339Nano))
+		if ok {
 			// Make sure times round-trip to the same time:
 			if !v.Equal(date) {
 				t.Fatalf("did not round-trip: %v", date)
 			}
-			// Make with the same zone offset:
+			// With the same zone offset:
 			_, off1 := v.Zone()
 			_, off2 := date.Zone()
 			if off1 != off2 {
 				t.Fatalf("did not round-trip: %v", date)
 			}
-		case string:
+		} else {
 			t.Fatalf("was not recovered: %v", date)
-		default:
-			t.Fatalf("invalid type %T: %v", v, date)
 		}
 	}
 
-	f.Fuzz(func(t *testing.T, sec, nsec int) {
+	f.Fuzz(func(t *testing.T, sec, nsec int64) {
 		// Reduce the search space.
 		if 1e12 < sec || sec < -1e12 {
 			// Dates before 29000BC and after 33000AD; I think we're safe.
@@ -91,7 +79,7 @@ func Fuzz_stringOrTime_2(f *testing.F) {
 			return
 		}
 
-		unix := time.Unix(int64(sec), int64(nsec))
+		unix := time.Unix(sec, nsec)
 		checkTime(t, unix)
 		checkTime(t, unix.UTC())
 		checkTime(t, unix.In(time.FixedZone("", -8*3600)))

embed/README.md

@@ -1,17 +1,19 @@
-# Embeddable WASM build of SQLite
+# Embeddable Wasm build of SQLite
 
-This folder includes an embeddable WASM build of SQLite 3.44.2 for use with
+This folder includes an embeddable Wasm build of SQLite 3.46.0 for use with
 [`github.com/ncruces/go-sqlite3`](https://pkg.go.dev/github.com/ncruces/go-sqlite3).
 
 The following optional features are compiled in:
 - [math functions](https://sqlite.org/lang_mathfunc.html)
-- [FTS3/4](https://sqlite.org/fts3.html)/[5](https://sqlite.org/fts5.html)
+- [FTS5](https://sqlite.org/fts5.html)
 - [JSON](https://sqlite.org/json1.html)
 - [R*Tree](https://sqlite.org/rtree.html)
 - [GeoPoly](https://sqlite.org/geopoly.html)
 - [soundex](https://sqlite.org/lang_corefunc.html#soundex)
+- [stat4](https://sqlite.org/compile.html#enable_stat4)
 - [base64](https://github.com/sqlite/sqlite/blob/master/ext/misc/base64.c)
 - [decimal](https://github.com/sqlite/sqlite/blob/master/ext/misc/decimal.c)
+- [ieee754](https://github.com/sqlite/sqlite/blob/master/ext/misc/ieee754.c)
 - [regexp](https://github.com/sqlite/sqlite/blob/master/ext/misc/regexp.c)
 - [series](https://github.com/sqlite/sqlite/blob/master/ext/misc/series.c)
 - [uint](https://github.com/sqlite/sqlite/blob/master/ext/misc/uint.c)
@@ -22,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

@@ -4,10 +4,11 @@ set -euo pipefail
 cd -P -- "$(dirname -- "$0")"
 
 ROOT=../
-BINARYEN="$ROOT/tools/binaryen-version_116/bin"
-WASI_SDK="$ROOT/tools/wasi-sdk-20.0/bin"
+BINARYEN="$ROOT/tools/binaryen-version_117/bin"
+WASI_SDK="$ROOT/tools/wasi-sdk-22.0/bin"
 
-"$WASI_SDK/clang" --target=wasm32-wasi -flto -g0 -O2 \
+"$WASI_SDK/clang" --target=wasm32-wasi -std=c17 -flto -g0 -O2 \
+	-Wall -Wextra -Wno-unused-parameter -Wno-unused-function \
 	-o sqlite3.wasm "$ROOT/sqlite3/main.c" \
 	-I"$ROOT/sqlite3" \
 	-mexec-model=reactor \
@@ -19,11 +20,12 @@ WASI_SDK="$ROOT/tools/wasi-sdk-20.0/bin"
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
 	-D_HAVE_SQLITE_CONFIG_H \
+	-DSQLITE_CUSTOM_INCLUDE=sqlite_opt.h \
 	$(awk '{print "-Wl,--export="$0}' exports.txt)
 
 trap 'rm -f sqlite3.tmp' EXIT
 "$BINARYEN/wasm-ctor-eval" -g -c _initialize sqlite3.wasm -o sqlite3.tmp
-"$BINARYEN/wasm-opt" -g --strip -c -O3 \
+"$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
 	sqlite3.tmp -o sqlite3.wasm \
 	--enable-simd --enable-mutable-globals --enable-multivalue \
 	--enable-bulk-memory --enable-reference-types \

embed/exports.txt

@@ -1,91 +1,130 @@
+aligned_alloc
 free
 malloc
 malloc_destructor
-sqlite3_errcode
-sqlite3_errstr
-sqlite3_errmsg
-sqlite3_error_offset
-sqlite3_open_v2
-sqlite3_close
-sqlite3_close_v2
-sqlite3_prepare_v3
-sqlite3_finalize
-sqlite3_reset
-sqlite3_step
-sqlite3_exec
-sqlite3_interrupt
-sqlite3_progress_handler_go
-sqlite3_clear_bindings
+sqlite3_anycollseq_init
+sqlite3_autovacuum_pages_go
+sqlite3_backup_finish
+sqlite3_backup_init
+sqlite3_backup_pagecount
+sqlite3_backup_remaining
+sqlite3_backup_step
+sqlite3_bind_blob64
+sqlite3_bind_double
+sqlite3_bind_int64
+sqlite3_bind_null
 sqlite3_bind_parameter_count
 sqlite3_bind_parameter_index
 sqlite3_bind_parameter_name
-sqlite3_bind_null
-sqlite3_bind_int64
-sqlite3_bind_double
-sqlite3_bind_text64
-sqlite3_bind_blob64
-sqlite3_bind_zeroblob64
 sqlite3_bind_pointer_go
-sqlite3_column_count
-sqlite3_column_name
-sqlite3_column_type
-sqlite3_column_int64
-sqlite3_column_double
-sqlite3_column_text
+sqlite3_bind_text64
+sqlite3_bind_value
+sqlite3_bind_zeroblob64
+sqlite3_blob_bytes
+sqlite3_blob_close
+sqlite3_blob_open
+sqlite3_blob_read
+sqlite3_blob_reopen
+sqlite3_blob_write
+sqlite3_busy_handler_go
+sqlite3_busy_timeout
+sqlite3_changes64
+sqlite3_clear_bindings
+sqlite3_close
+sqlite3_close_v2
+sqlite3_collation_needed_go
 sqlite3_column_blob
 sqlite3_column_bytes
-sqlite3_blob_open
-sqlite3_blob_close
-sqlite3_blob_reopen
-sqlite3_blob_bytes
-sqlite3_blob_read
-sqlite3_blob_write
-sqlite3_backup_init
-sqlite3_backup_step
-sqlite3_backup_finish
-sqlite3_backup_remaining
-sqlite3_backup_pagecount
-sqlite3_uri_parameter
-sqlite3_uri_key
-sqlite3_changes64
-sqlite3_last_insert_rowid
-sqlite3_get_autocommit
-sqlite3_anycollseq_init
+sqlite3_column_count
+sqlite3_column_database_name
+sqlite3_column_decltype
+sqlite3_column_double
+sqlite3_column_int64
+sqlite3_column_name
+sqlite3_column_origin_name
+sqlite3_column_table_name
+sqlite3_column_text
+sqlite3_column_type
+sqlite3_column_value
+sqlite3_columns_go
+sqlite3_commit_hook_go
+sqlite3_config_log_go
+sqlite3_create_aggregate_function_go
 sqlite3_create_collation_go
 sqlite3_create_function_go
-sqlite3_create_aggregate_function_go
+sqlite3_create_module_go
 sqlite3_create_window_function_go
-sqlite3_aggregate_context
-sqlite3_user_data
-sqlite3_set_auxdata_go
+sqlite3_database_file_object
+sqlite3_db_config
+sqlite3_db_filename
+sqlite3_db_name
+sqlite3_db_readonly
+sqlite3_db_release_memory
+sqlite3_declare_vtab
+sqlite3_errcode
+sqlite3_errmsg
+sqlite3_error_offset
+sqlite3_errstr
+sqlite3_exec
+sqlite3_filename_database
+sqlite3_filename_journal
+sqlite3_filename_wal
+sqlite3_finalize
+sqlite3_get_autocommit
 sqlite3_get_auxdata
-sqlite3_value_type
-sqlite3_value_int64
-sqlite3_value_double
-sqlite3_value_text
-sqlite3_value_blob
-sqlite3_value_bytes
-sqlite3_value_pointer_go
-sqlite3_result_null
-sqlite3_result_int64
-sqlite3_result_double
-sqlite3_result_text64
+sqlite3_interrupt
+sqlite3_last_insert_rowid
+sqlite3_limit
+sqlite3_open_v2
+sqlite3_overload_function
+sqlite3_prepare_v3
+sqlite3_progress_handler_go
+sqlite3_reset
 sqlite3_result_blob64
-sqlite3_result_zeroblob64
-sqlite3_result_pointer_go
-sqlite3_result_value
+sqlite3_result_double
 sqlite3_result_error
 sqlite3_result_error_code
 sqlite3_result_error_nomem
 sqlite3_result_error_toobig
-sqlite3_create_module_go
-sqlite3_declare_vtab
-sqlite3_vtab_config_go
+sqlite3_result_int64
+sqlite3_result_null
+sqlite3_result_pointer_go
+sqlite3_result_text64
+sqlite3_result_value
+sqlite3_result_zeroblob64
+sqlite3_rollback_hook_go
+sqlite3_set_authorizer_go
+sqlite3_set_auxdata_go
+sqlite3_set_last_insert_rowid
+sqlite3_step
+sqlite3_stmt_busy
+sqlite3_stmt_readonly
+sqlite3_stmt_status
+sqlite3_total_changes64
+sqlite3_txn_state
+sqlite3_update_hook_go
+sqlite3_uri_key
+sqlite3_uri_parameter
+sqlite3_value_blob
+sqlite3_value_bytes
+sqlite3_value_double
+sqlite3_value_dup
+sqlite3_value_free
+sqlite3_value_int64
+sqlite3_value_nochange
+sqlite3_value_numeric_type
+sqlite3_value_pointer_go
+sqlite3_value_text
+sqlite3_value_type
 sqlite3_vtab_collation
+sqlite3_vtab_config_go
 sqlite3_vtab_distinct
 sqlite3_vtab_in
 sqlite3_vtab_in_first
 sqlite3_vtab_in_next
-sqlite3_vtab_rhs_value
 sqlite3_vtab_nochange
-sqlite3_vtab_on_conflict
+sqlite3_vtab_on_conflict
+sqlite3_vtab_rhs_value
+sqlite3_wal_autocheckpoint
+sqlite3_wal_checkpoint_v2
+sqlite3_wal_hook_go

error.go

@@ -44,8 +44,7 @@ func (e *Error) Error() string {
 	}
 
 	if e.msg != "" {
-		b.WriteByte(':')
-		b.WriteByte(' ')
+		b.WriteString(": ")
 		b.WriteString(e.msg)
 	}
 
@@ -139,12 +138,14 @@ func (e ExtendedErrorCode) Timeout() bool {
 
 func errorCode(err error, def ErrorCode) (msg string, code uint32) {
 	switch code := err.(type) {
-	case ErrorCode:
-		return "", uint32(code)
-	case ExtendedErrorCode:
-		return "", uint32(code)
 	case nil:
 		return "", _OK
+	case ErrorCode:
+		return "", uint32(code)
+	case xErrorCode:
+		return "", uint32(code)
+	case *Error:
+		return code.msg, uint32(code.code)
 	}
 
 	var ecode ErrorCode

error_test.go

@@ -135,7 +135,7 @@ func Test_ErrorCode_Error(t *testing.T) {
 	// Test all error codes.
 	for i := 0; i == int(ErrorCode(i)); i++ {
 		want := "sqlite3: "
-		r := db.call(db.api.errstr, uint64(i))
+		r := db.call("sqlite3_errstr", uint64(i))
 		want += util.ReadString(db.mod, uint32(r), _MAX_NAME)
 
 		got := ErrorCode(i).Error()
@@ -157,7 +157,7 @@ func Test_ExtendedErrorCode_Error(t *testing.T) {
 	// Test all extended error codes.
 	for i := 0; i == int(ExtendedErrorCode(i)); i++ {
 		want := "sqlite3: "
-		r := db.call(db.api.errstr, uint64(i))
+		r := db.call("sqlite3_errstr", uint64(i))
 		want += util.ReadString(db.mod, uint32(r), _MAX_NAME)
 
 		got := ExtendedErrorCode(i).Error()

example_test.go

@@ -16,7 +16,7 @@ func Example() {
 		log.Fatal(err)
 	}
 
-	err = db.Exec(`CREATE TABLE IF NOT EXISTS users (id INT, name VARCHAR(10))`)
+	err = db.Exec(`CREATE TABLE users (id INT, name VARCHAR(10))`)
 	if err != nil {
 		log.Fatal(err)
 	}

ext/array/array.go

@@ -1,4 +1,6 @@
 // Package array provides the array table-valued SQL function.
+//
+// https://sqlite.org/carray.html
 package array
 
 import (
@@ -6,17 +8,17 @@ import (
 	"reflect"
 
 	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
 )
 
 // Register registers the array single-argument, table-valued SQL function.
-// The argument must be an [sqlite3.Pointer] to a Go slice or array
-// of ints, floats, bools, strings or blobs.
-//
-// https://sqlite.org/carray.html
+// 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(db *sqlite3.Conn, arg ...string) (array, error) {
-			err := db.DeclareVtab(`CREATE TABLE x(value, array HIDDEN)`)
+	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
 		})
 }
@@ -102,7 +104,7 @@ func (c *cursor) Column(ctx *sqlite3.Context, n int) error {
 		ctx.ResultBlob(v.Bytes())
 
 	default:
-		return fmt.Errorf("array: unsupported element:%.0w %v", sqlite3.MISMATCH, v.Type())
+		return fmt.Errorf("array: unsupported element:%.0w %v", sqlite3.MISMATCH, util.ReflectType(v))
 	}
 	return nil
 }
@@ -119,17 +121,16 @@ func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
 	return nil
 }
 
-func indexable(v reflect.Value) (_ reflect.Value, err error) {
-	if v.Kind() == reflect.Slice {
+func indexable(v reflect.Value) (reflect.Value, error) {
+	switch v.Kind() {
+	case reflect.Slice:
 		return v, nil
-	}
-	if v.Kind() == reflect.Array {
+	case reflect.Array:
 		return v, nil
-	}
-	if v.Kind() == reflect.Pointer {
+	case reflect.Pointer:
 		if v := v.Elem(); v.Kind() == reflect.Array {
 			return v, nil
 		}
 	}
-	return v, fmt.Errorf("array: unsupported argument:%.0w %v", sqlite3.MISMATCH, v.Type())
+	return v, fmt.Errorf("array: unsupported argument:%.0w %v", sqlite3.MISMATCH, util.ReflectType(v))
 }

ext/array/array_test.go

@@ -11,9 +11,10 @@ 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/internal/testcfg"
 )
 
-func Example() {
+func Example_driver() {
 	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
 		array.Register(c)
 		return nil
@@ -51,7 +52,45 @@ func Example() {
 	// geopoly_within
 }
 
+func Example() {
+	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
+		WHERE name like 'geopoly%' AND narg IN array(?)`)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer stmt.Close()
+
+	err = stmt.BindPointer(1, [...]int{2, 3, 4})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	for stmt.Step() {
+		fmt.Printf("%s\n", stmt.ColumnText(0))
+	}
+	if err := stmt.Err(); err != nil {
+		log.Fatal(err)
+	}
+	// Unordered output:
+	// geopoly_regular
+	// geopoly_overlap
+	// geopoly_contains_point
+	// geopoly_within
+}
+
 func Test_cursor_Column(t *testing.T) {
+	t.Parallel()
+
 	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
 		array.Register(c)
 		return nil
@@ -90,3 +129,29 @@ func Test_cursor_Column(t *testing.T) {
 		log.Fatal(err)
 	}
 }
+
+func Test_array_errors(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	array.Register(db)
+
+	err = db.Exec(`SELECT * FROM array()`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`SELECT * FROM array(?)`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+}

ext/blob/blob.go

@@ -1,70 +0,0 @@
-// Package blob provides an alternative interface to incremental BLOB I/O.
-package blob
-
-import (
-	"errors"
-
-	"github.com/ncruces/go-sqlite3"
-	"github.com/ncruces/go-sqlite3/internal/util"
-)
-
-// Register registers the blob_open SQL function:
-//
-//	blob_open(schema, table, column, rowid, flags, callback, args...)
-//
-// The callback must be an [sqlite3.Pointer] to an [OpenCallback].
-// Any optional args will be passed to the callback,
-// along with the [sqlite3.Blob] handle.
-//
-// https://sqlite.org/c3ref/blob.html
-func Register(db *sqlite3.Conn) {
-	db.CreateFunction("blob_open", -1,
-		sqlite3.DETERMINISTIC|sqlite3.DIRECTONLY, openBlob)
-}
-
-func openBlob(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	if len(arg) < 6 {
-		ctx.ResultError(util.ErrorString("wrong number of arguments to function blob_open()"))
-		return
-	}
-
-	row := arg[3].Int64()
-
-	var err error
-	blob, ok := ctx.GetAuxData(0).(*sqlite3.Blob)
-	if ok {
-		err = blob.Reopen(row)
-		if errors.Is(err, sqlite3.MISUSE) {
-			// Blob was closed (db, table, column or write changed).
-			ok = false
-		}
-	}
-
-	if !ok {
-		db := arg[0].Text()
-		table := arg[1].Text()
-		column := arg[2].Text()
-		write := arg[4].Bool()
-		blob, err = ctx.Conn().OpenBlob(db, table, column, row, write)
-	}
-	if err != nil {
-		ctx.ResultError(err)
-		return
-	}
-
-	fn := arg[5].Pointer().(OpenCallback)
-	err = fn(blob, arg[6:]...)
-	if err != nil {
-		ctx.ResultError(err)
-		return
-	}
-
-	// This ensures the blob is closed if db, table, column or write change.
-	ctx.SetAuxData(0, blob)
-	ctx.SetAuxData(1, blob)
-	ctx.SetAuxData(2, blob)
-	ctx.SetAuxData(4, blob)
-}
-
-// OpenCallback is the type for the blob_open callback.
-type OpenCallback func(*sqlite3.Blob, ...sqlite3.Value) error

ext/blob/blob_test.go

@@ -1,61 +0,0 @@
-package blob_test
-
-import (
-	"io"
-	"log"
-	"os"
-
-	"github.com/ncruces/go-sqlite3"
-	"github.com/ncruces/go-sqlite3/driver"
-	_ "github.com/ncruces/go-sqlite3/embed"
-	"github.com/ncruces/go-sqlite3/ext/blob"
-	_ "github.com/ncruces/go-sqlite3/vfs/memdb"
-)
-
-func Example() {
-	// Open the database, registering the extension.
-	db, err := driver.Open("file:/test.db?vfs=memdb", func(conn *sqlite3.Conn) error {
-		blob.Register(conn)
-		return nil
-	})
-
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer db.Close()
-
-	_, err = db.Exec(`CREATE TABLE IF NOT EXISTS test (col)`)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	const message = "Hello BLOB!"
-
-	// Create the BLOB.
-	_, err = db.Exec(`INSERT INTO test VALUES (?)`, sqlite3.ZeroBlob(len(message)))
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	// Write the BLOB.
-	_, err = db.Exec(`SELECT blob_open('main', 'test', 'col', last_insert_rowid(), true, ?)`,
-		sqlite3.Pointer[blob.OpenCallback](func(blob *sqlite3.Blob, _ ...sqlite3.Value) error {
-			_, err = io.WriteString(blob, message)
-			return err
-		}))
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	// Read the BLOB.
-	_, err = db.Exec(`SELECT blob_open('main', 'test', 'col', rowid, false, ?) FROM test`,
-		sqlite3.Pointer[blob.OpenCallback](func(blob *sqlite3.Blob, _ ...sqlite3.Value) error {
-			_, err = io.Copy(os.Stdout, blob)
-			return err
-		}))
-	if err != nil {
-		log.Fatal(err)
-	}
-	// Output:
-	// Hello BLOB!
-}

ext/blobio/blob.go

@@ -0,0 +1,139 @@
+// Package blobio provides an SQL interface to incremental BLOB I/O.
+package blobio
+
+import (
+	"errors"
+	"io"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
+)
+
+// Register registers the SQL functions:
+//
+//	readblob(schema, table, column, rowid, offset, n)
+//
+// Reads n bytes of a blob, starting at offset.
+//
+//	writeblob(schema, table, column, rowid, offset, data)
+//
+// Writes data into a blob, at the given offset.
+//
+//	openblob(schema, table, column, rowid, write, callback, args...)
+//
+// Opens blobs for reading or writing.
+// The callback is invoked for each open blob,
+// and must be bound to an [OpenCallback],
+// using [sqlite3.BindPointer] or [sqlite3.Pointer].
+// The optional args will be passed to the callback,
+// 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)
+}
+
+// OpenCallback is the type for the openblob callback.
+type OpenCallback func(*sqlite3.Blob, ...sqlite3.Value) error
+
+func readblob(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	blob, err := getAuxBlob(ctx, arg, false)
+	if err != nil {
+		ctx.ResultError(err)
+		return
+	}
+
+	_, err = blob.Seek(arg[4].Int64(), io.SeekStart)
+	if err != nil {
+		ctx.ResultError(err)
+		return
+	}
+
+	n := arg[5].Int64()
+	if n <= 0 {
+		return
+	}
+	buf := make([]byte, n)
+
+	_, err = io.ReadFull(blob, buf)
+	if err != nil {
+		ctx.ResultError(err)
+		return
+	}
+
+	ctx.ResultBlob(buf)
+	setAuxBlob(ctx, blob, false)
+}
+
+func writeblob(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	blob, err := getAuxBlob(ctx, arg, true)
+	if err != nil {
+		ctx.ResultError(err)
+		return
+	}
+
+	_, err = blob.Seek(arg[4].Int64(), io.SeekStart)
+	if err != nil {
+		ctx.ResultError(err)
+		return
+	}
+
+	_, err = blob.Write(arg[5].RawBlob())
+	if err != nil {
+		ctx.ResultError(err)
+		return
+	}
+
+	setAuxBlob(ctx, blob, false)
+}
+
+func openblob(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	if len(arg) < 6 {
+		ctx.ResultError(util.ErrorString("openblob: wrong number of arguments"))
+		return
+	}
+
+	blob, err := getAuxBlob(ctx, arg, arg[4].Bool())
+	if err != nil {
+		ctx.ResultError(err)
+		return
+	}
+
+	fn := arg[5].Pointer().(OpenCallback)
+	err = fn(blob, arg[6:]...)
+	if err != nil {
+		ctx.ResultError(err)
+		return
+	}
+
+	setAuxBlob(ctx, blob, true)
+}
+
+func getAuxBlob(ctx sqlite3.Context, arg []sqlite3.Value, write bool) (*sqlite3.Blob, error) {
+	row := arg[3].Int64()
+
+	if blob, ok := ctx.GetAuxData(0).(*sqlite3.Blob); ok {
+		if err := blob.Reopen(row); errors.Is(err, sqlite3.MISUSE) {
+			// Blob was closed (db, table, column or write changed).
+		} else {
+			return blob, err
+		}
+	}
+
+	db := arg[0].Text()
+	table := arg[1].Text()
+	column := arg[2].Text()
+	return ctx.Conn().OpenBlob(db, table, column, row, write)
+}
+
+func setAuxBlob(ctx sqlite3.Context, blob *sqlite3.Blob, open bool) {
+	// This ensures the blob is closed if db, table, column or write change.
+	ctx.SetAuxData(0, blob) // db
+	ctx.SetAuxData(1, blob) // table
+	ctx.SetAuxData(2, blob) // column
+	if open {
+		ctx.SetAuxData(4, blob) // write
+	}
+}

ext/blobio/blob_test.go

@@ -0,0 +1,185 @@
+package blobio_test
+
+import (
+	"io"
+	"log"
+	"os"
+	"reflect"
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/driver"
+	_ "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/internal/testcfg"
+	_ "github.com/ncruces/go-sqlite3/vfs/memdb"
+)
+
+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
+	})
+
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec(`CREATE TABLE test (col)`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	const message = "Hello BLOB!"
+
+	// Create the BLOB.
+	_, err = db.Exec(`INSERT INTO test VALUES (?)`, sqlite3.ZeroBlob(len(message)))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Write the BLOB.
+	_, err = db.Exec(`SELECT writeblob('main', 'test', 'col', last_insert_rowid(), 0, ?)`, message)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Read the BLOB.
+	_, err = db.Exec(`SELECT openblob('main', 'test', 'col', rowid, false, ?) FROM test`,
+		sqlite3.Pointer[blobio.OpenCallback](func(blob *sqlite3.Blob, _ ...sqlite3.Value) error {
+			_, err = io.Copy(os.Stdout, blob)
+			return err
+		}))
+	if err != nil {
+		log.Fatal(err)
+	}
+	// Output:
+	// Hello BLOB!
+}
+
+func Test_readblob(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	blobio.Register(db)
+	array.Register(db)
+
+	err = db.Exec(`SELECT readblob()`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`
+		CREATE TABLE test1 (col);
+		CREATE TABLE test2 (col);
+		INSERT INTO test1 VALUES (x'cafe');
+		INSERT INTO test2 VALUES (x'babe');
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT readblob('main', value, 'col', 1, 1, 1) FROM array(?)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer stmt.Close()
+
+	err = stmt.BindPointer(1, []string{"test1", "test2"})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if stmt.Step() {
+		got := stmt.ColumnText(0)
+		if got != "\xfe" {
+			t.Errorf("got %q", got)
+		}
+	}
+
+	if stmt.Step() {
+		got := stmt.ColumnText(0)
+		if got != "\xbe" {
+			t.Errorf("got %q", got)
+		}
+	}
+
+	err = stmt.Err()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func Test_openblob(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	blobio.Register(db)
+	array.Register(db)
+
+	err = db.Exec(`SELECT openblob()`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`
+		CREATE TABLE test1 (col);
+		CREATE TABLE test2 (col);
+		INSERT INTO test1 VALUES (x'cafe');
+		INSERT INTO test2 VALUES (x'babe');
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT openblob('main', value, 'col', 1, false, ?) FROM array(?)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer stmt.Close()
+
+	var got []string
+	err = stmt.BindPointer(1, blobio.OpenCallback(func(b *sqlite3.Blob, _ ...sqlite3.Value) error {
+		d, err := io.ReadAll(b)
+		if err != nil {
+			return err
+		}
+		got = append(got, string(d))
+		return nil
+	}))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = stmt.BindPointer(2, []string{"test1", "test2"})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = stmt.Exec()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want := []string{"\xca\xfe", "\xba\xbe"}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("got %v, want %v", got, want)
+	}
+}

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

@@ -0,0 +1,36 @@
+package csv
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/ncruces/go-sqlite3/util/vtabutil"
+)
+
+func uintArg(key, val string) (int, error) {
+	i, err := strconv.ParseUint(val, 10, 15)
+	if err != nil {
+		return 0, fmt.Errorf("csv: invalid %q parameter: %s", key, val)
+	}
+	return int(i), nil
+}
+
+func boolArg(key, val string) (bool, error) {
+	if val == "" {
+		return true, nil
+	}
+	b, ok := util.ParseBool(val)
+	if ok {
+		return b, nil
+	}
+	return false, fmt.Errorf("csv: invalid %q parameter: %s", key, val)
+}
+
+func runeArg(key, val string) (rune, error) {
+	r, _, tail, err := strconv.UnquoteChar(vtabutil.Unquote(val), 0)
+	if tail != "" || err != nil {
+		return 0, fmt.Errorf("csv: invalid %q parameter: %s", key, val)
+	}
+	return r, nil
+}

ext/csv/arg_test.go

@@ -1,8 +1,14 @@
 package csv
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/ncruces/go-sqlite3/util/vtabutil"
+)
+
+func Test_uintArg(t *testing.T) {
+	t.Parallel()
 
-func Test_uintParam(t *testing.T) {
 	tests := []struct {
 		arg string
 		key string
@@ -18,22 +24,24 @@ func Test_uintParam(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.arg, func(t *testing.T) {
-			key, val := getParam(tt.arg)
+			key, val := vtabutil.NamedArg(tt.arg)
 			if key != tt.key {
-				t.Errorf("getParam() %v, want err %v", key, tt.key)
+				t.Errorf("NamedArg() %v, want err %v", key, tt.key)
 			}
-			got, err := uintParam(key, val)
+			got, err := uintArg(key, val)
 			if (err != nil) != tt.err {
-				t.Fatalf("uintParam() error = %v, want err %v", err, tt.err)
+				t.Fatalf("uintArg() error = %v, want err %v", err, tt.err)
 			}
 			if got != tt.val {
-				t.Errorf("uintParam() = %v, want %v", got, tt.val)
+				t.Errorf("uintArg() = %v, want %v", got, tt.val)
 			}
 		})
 	}
 }
 
-func Test_boolParam(t *testing.T) {
+func Test_boolArg(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		arg string
 		key string
@@ -54,22 +62,24 @@ func Test_boolParam(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.arg, func(t *testing.T) {
-			key, val := getParam(tt.arg)
+			key, val := vtabutil.NamedArg(tt.arg)
 			if key != tt.key {
-				t.Errorf("getParam() %v, want err %v", key, tt.key)
+				t.Errorf("NamedArg() %v, want err %v", key, tt.key)
 			}
-			got, err := boolParam(key, val)
+			got, err := boolArg(key, val)
 			if (err != nil) != tt.err {
-				t.Fatalf("boolParam() error = %v, want err %v", err, tt.err)
+				t.Fatalf("boolArg() error = %v, want err %v", err, tt.err)
 			}
 			if got != tt.val {
-				t.Errorf("boolParam() = %v, want %v", got, tt.val)
+				t.Errorf("boolArg() = %v, want %v", got, tt.val)
 			}
 		})
 	}
 }
 
-func Test_runeParam(t *testing.T) {
+func Test_runeArg(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		arg string
 		key string
@@ -86,16 +96,16 @@ func Test_runeParam(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.arg, func(t *testing.T) {
-			key, val := getParam(tt.arg)
+			key, val := vtabutil.NamedArg(tt.arg)
 			if key != tt.key {
-				t.Errorf("getParam() %v, want err %v", key, tt.key)
+				t.Errorf("NamedArg() %v, want err %v", key, tt.key)
 			}
-			got, err := runeParam(key, val)
+			got, err := runeArg(key, val)
 			if (err != nil) != tt.err {
-				t.Fatalf("runeParam() error = %v, want err %v", err, tt.err)
+				t.Fatalf("runeArg() error = %v, want err %v", err, tt.err)
 			}
 			if got != tt.val {
-				t.Errorf("runeParam() = %v, want %v", got, tt.val)
+				t.Errorf("runeArg() = %v, want %v", got, tt.val)
 			}
 		})
 	}

ext/csv/csv.go

@@ -7,28 +7,30 @@
 package csv
 
 import (
+	"bufio"
 	"encoding/csv"
+	"errors"
 	"fmt"
 	"io"
-	"math"
-	"os"
+	"io/fs"
+	"strconv"
 	"strings"
 
 	"github.com/ncruces/go-sqlite3"
+	"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 read it from disk.
+// If a filename is specified, [os.Open] is used to open the file.
 func Register(db *sqlite3.Conn) {
-	RegisterOpen(db, func(name string) (io.ReaderAt, error) {
-		return os.Open(name)
-	})
+	RegisterFS(db, osutil.FS{})
 }
 
-// RegisterOpen registers the CSV virtual table.
-// If a filename is specified, open is used to open the file.
-func RegisterOpen(db *sqlite3.Conn, open func(name string) (io.ReaderAt, error)) {
-	declare := func(db *sqlite3.Conn, arg ...string) (_ *table, err error) {
+// RegisterFS registers the CSV virtual table.
+// If a filename is specified, fsys is used to open the file.
+func RegisterFS(db *sqlite3.Conn, fsys fs.FS) {
+	declare := func(db *sqlite3.Conn, _, _, _ string, arg ...string) (_ *table, err error) {
 		var (
 			filename string
 			data     string
@@ -36,28 +38,31 @@ func RegisterOpen(db *sqlite3.Conn, open func(name string) (io.ReaderAt, error))
 			header   bool
 			columns  int  = -1
 			comma    rune = ','
+			comment  rune
 
 			done = map[string]struct{}{}
 		)
 
-		for _, arg := range arg[3:] {
-			key, val := getParam(arg)
+		for _, arg := range arg {
+			key, val := vtabutil.NamedArg(arg)
 			if _, ok := done[key]; ok {
 				return nil, fmt.Errorf("csv: more than one %q parameter", key)
 			}
 			switch key {
 			case "filename":
-				filename = unquoteParam(val)
+				filename = vtabutil.Unquote(val)
 			case "data":
-				data = unquoteParam(val)
+				data = vtabutil.Unquote(val)
 			case "schema":
-				schema = unquoteParam(val)
+				schema = vtabutil.Unquote(val)
 			case "header":
-				header, err = boolParam(key, val)
+				header, err = boolArg(key, val)
 			case "columns":
-				columns, err = uintParam(key, val)
+				columns, err = uintArg(key, val)
 			case "comma":
-				comma, err = runeParam(key, val)
+				comma, err = runeArg(key, val)
+			case "comment":
+				comment, err = runeArg(key, val)
 			default:
 				return nil, fmt.Errorf("csv: unknown %q parameter", key)
 			}
@@ -68,44 +73,45 @@ func RegisterOpen(db *sqlite3.Conn, open func(name string) (io.ReaderAt, error))
 		}
 
 		if (filename == "") == (data == "") {
-			return nil, fmt.Errorf(`csv: must specify either "filename" or "data" but not both`)
-		}
-
-		var r io.ReaderAt
-		if filename != "" {
-			r, err = open(filename)
-		} else {
-			r = strings.NewReader(data)
-		}
-		if err != nil {
-			return nil, err
+			return nil, errors.New(`csv: must specify either "filename" or "data" but not both`)
 		}
 
 		table := &table{
-			r:      r,
-			comma:  comma,
-			header: header,
+			fsys:    fsys,
+			name:    filename,
+			data:    data,
+			comma:   comma,
+			comment: comment,
+			header:  header,
 		}
-		defer func() {
-			if err != nil {
-				table.Close()
-			}
-		}()
 
-		if schema == "" && (header || columns < 0) {
-			csv := table.newReader()
-			row, err := csv.Read()
-			if err != nil {
-				return nil, err
+		if schema == "" {
+			var row []string
+			if header || columns < 0 {
+				csv, c, err := table.newReader()
+				defer c.Close()
+				if err != nil {
+					return nil, err
+				}
+				row, err = csv.Read()
+				if err != nil {
+					return nil, err
+				}
 			}
 			schema = getSchema(header, columns, row)
+		} else {
+			defer func() {
+				if err == nil {
+					table.typs, err = getColumnAffinities(schema)
+				}
+			}()
 		}
 
-		err = db.DeclareVtab(schema)
+		err = db.DeclareVTab(schema)
 		if err != nil {
 			return nil, err
 		}
-		err = db.VtabConfig(sqlite3.VTAB_DIRECTONLY)
+		err = db.VTabConfig(sqlite3.VTAB_DIRECTONLY)
 		if err != nil {
 			return nil, err
 		}
@@ -116,18 +122,13 @@ func RegisterOpen(db *sqlite3.Conn, open func(name string) (io.ReaderAt, error))
 }
 
 type table struct {
-	r      io.ReaderAt
-	comma  rune
-	header bool
-}
-
-func (t *table) Close() error {
-	if c, ok := t.r.(io.Closer); ok {
-		err := c.Close()
-		t.r = nil
-		return err
-	}
-	return nil
+	fsys    fs.FS
+	name    string
+	data    string
+	typs    []affinity
+	comma   rune
+	comment rune
+	header  bool
 }
 
 func (t *table) BestIndex(idx *sqlite3.IndexInfo) error {
@@ -143,29 +144,77 @@ func (t *table) Rename(new string) error {
 	return nil
 }
 
-func (t *table) Integrity(schema, table string, flags int) (err error) {
-	if flags&1 == 0 {
-		_, err = t.newReader().ReadAll()
+func (t *table) Integrity(schema, table string, flags int) error {
+	if flags&1 != 0 {
+		return nil
+	}
+	csv, c, err := t.newReader()
+	if err != nil {
+		return err
+	}
+	defer c.Close()
+	_, err = csv.ReadAll()
+	return err
+}
+
+func (t *table) newReader() (*csv.Reader, io.Closer, error) {
+	var r io.Reader
+	var c io.Closer
+	if t.name != "" {
+		f, err := t.fsys.Open(t.name)
+		if err != nil {
+			return nil, f, err
+		}
+
+		buf := bufio.NewReader(f)
+		bom, err := buf.Peek(3)
+		if err != nil {
+			return nil, f, err
+		}
+		if string(bom) == "\xEF\xBB\xBF" {
+			buf.Discard(3)
+		}
+
+		r = buf
+		c = f
+	} else {
+		r = strings.NewReader(t.data)
+		c = io.NopCloser(r)
+	}
+
+	csv := csv.NewReader(r)
+	csv.ReuseRecord = true
+	csv.Comma = t.comma
+	csv.Comment = t.comment
+	return csv, c, nil
+}
+
+type cursor struct {
+	table  *table
+	closer io.Closer
+	csv    *csv.Reader
+	row    []string
+	rowID  int64
+}
+
+func (c *cursor) Close() (err error) {
+	if c.closer != nil {
+		err = c.closer.Close()
+		c.closer = nil
 	}
 	return err
 }
 
-func (t *table) newReader() *csv.Reader {
-	csv := csv.NewReader(io.NewSectionReader(t.r, 0, math.MaxInt64))
-	csv.ReuseRecord = true
-	csv.Comma = t.comma
-	return csv
-}
-
-type cursor struct {
-	table *table
-	rowID int64
-	row   []string
-	csv   *csv.Reader
-}
-
 func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
-	c.csv = c.table.newReader()
+	err := c.Close()
+	if err != nil {
+		return err
+	}
+
+	c.csv, c.closer, err = c.table.newReader()
+	if err != nil {
+		return err
+	}
 	if c.table.header {
 		c.Next() // skip header
 	}
@@ -192,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,6 +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/internal/testcfg"
 )
 
 func Example() {
@@ -20,7 +21,7 @@ func Example() {
 	csv.Register(db)
 
 	err = db.Exec(`
-		CREATE VIRTUAL TABLE IF NOT EXISTS eurofxref USING csv(
+		CREATE VIRTUAL TABLE eurofxref USING csv(
 			filename = 'testdata/eurofxref.csv',
 			header   = YES,
 			columns  = 42,
@@ -51,6 +52,8 @@ func Example() {
 }
 
 func TestRegister(t *testing.T) {
+	t.Parallel()
+
 	db, err := sqlite3.Open(":memory:")
 	if err != nil {
 		t.Fatal(err)
@@ -60,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)
@@ -82,8 +87,8 @@ Robert	"Griesemer"	"gri"`
 	if !stmt.Step() {
 		t.Fatal("no rows")
 	}
-	if got := stmt.ColumnText(1); got != "Pike" {
-		t.Errorf("got %q want Pike", got)
+	if got := stmt.ColumnText(0); got != "Rob" {
+		t.Errorf("got %q want Rob", got)
 	}
 	if stmt.Step() {
 		t.Fatal("more rows")
@@ -96,16 +101,67 @@ Robert	"Griesemer"	"gri"`
 
 	err = db.Exec(`PRAGMA integrity_check`)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
+	}
+
+	err = db.Exec(`PRAGMA quick_check`)
+	if err != nil {
+		t.Error(err)
 	}
 
 	err = db.Exec(`DROP TABLE temp.csv`)
 	if err != nil {
-		log.Fatal(err)
+		t.Error(err)
+	}
+}
+
+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()
+
 	db, err := sqlite3.Open(":memory:")
 	if err != nil {
 		t.Fatal(err)

ext/csv/params.go

@@ -1,65 +0,0 @@
-package csv
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-)
-
-func getParam(arg string) (key, val string) {
-	key, val, _ = strings.Cut(arg, "=")
-	key = strings.TrimSpace(key)
-	val = strings.TrimSpace(val)
-	return
-}
-
-func uintParam(key, val string) (int, error) {
-	i, err := strconv.ParseUint(val, 10, 15)
-	if err != nil {
-		return 0, fmt.Errorf("csv: invalid %q parameter: %s", key, val)
-	}
-	return int(i), nil
-}
-
-func boolParam(key, val string) (bool, error) {
-	if val == "" || val == "1" ||
-		strings.EqualFold(val, "true") ||
-		strings.EqualFold(val, "yes") ||
-		strings.EqualFold(val, "on") {
-		return true, nil
-	}
-	if val == "0" ||
-		strings.EqualFold(val, "false") ||
-		strings.EqualFold(val, "no") ||
-		strings.EqualFold(val, "off") {
-		return false, nil
-	}
-	return false, fmt.Errorf("csv: invalid %q parameter: %s", key, val)
-}
-
-func runeParam(key, val string) (rune, error) {
-	r, _, tail, err := strconv.UnquoteChar(unquoteParam(val), 0)
-	if tail != "" || err != nil {
-		return 0, fmt.Errorf("csv: invalid %q parameter: %s", key, val)
-	}
-	return r, nil
-}
-
-func unquoteParam(val string) string {
-	if len(val) < 2 {
-		return val
-	}
-	if val[0] != val[len(val)-1] {
-		return val
-	}
-	var old, new string
-	switch val[0] {
-	default:
-		return val
-	case '"':
-		old, new = `""`, `"`
-	case '\'':
-		old, new = `''`, `'`
-	}
-	return strings.ReplaceAll(val[1:len(val)-1], old, new)
-}

ext/csv/schema.go

@@ -8,9 +8,9 @@ import (
 )
 
 func getSchema(header bool, columns int, row []string) string {
-	var sep = ""
+	var sep string
 	var str strings.Builder
-	str.WriteString(`CREATE TABLE x(`)
+	str.WriteString("CREATE TABLE x(")
 
 	if 0 <= columns && columns < len(row) {
 		row = row[:columns]
@@ -20,15 +20,17 @@ func getSchema(header bool, columns int, row []string) string {
 		if header && f != "" {
 			str.WriteString(sqlite3.QuoteIdentifier(f))
 		} else {
-			str.WriteByte('c')
+			str.WriteString("c")
 			str.WriteString(strconv.Itoa(i + 1))
 		}
+		str.WriteString(" TEXT")
 		sep = ","
 	}
 	for i := len(row); i < columns; i++ {
 		str.WriteString(sep)
-		str.WriteByte('c')
+		str.WriteString("c")
 		str.WriteString(strconv.Itoa(i + 1))
+		str.WriteString(" TEXT")
 		sep = ","
 	}
 	str.WriteByte(')')

ext/csv/schema_test.go

@@ -3,16 +3,20 @@ package csv
 import "testing"
 
 func Test_getSchema(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		header  bool
 		columns int
 		row     []string
 		want    string
 	}{
-		{true, 2, nil, `CREATE TABLE x(c1,c2)`},
-		{false, 2, nil, `CREATE TABLE x(c1,c2)`},
-		{true, 3, []string{"abc", ""}, `CREATE TABLE x("abc",c2,c3)`},
-		{true, 1, []string{"abc", "def"}, `CREATE TABLE x("abc")`},
+		{true, 2, nil, `CREATE TABLE x(c1 TEXT,c2 TEXT)`},
+		{false, 2, nil, `CREATE TABLE x(c1 TEXT,c2 TEXT)`},
+		{false, -1, []string{"abc", ""}, `CREATE TABLE x(c1 TEXT,c2 TEXT)`},
+		{true, 3, []string{"abc", ""}, `CREATE TABLE x("abc" TEXT,c2 TEXT,c3 TEXT)`},
+		{true, -1, []string{"abc", "def"}, `CREATE TABLE x("abc" TEXT,"def" TEXT)`},
+		{true, 1, []string{"abc", "def"}, `CREATE TABLE x("abc" TEXT)`},
 	}
 	for _, tt := range tests {
 		t.Run(tt.want, func(t *testing.T) {

ext/csv/testdata/eurofxref.csv

@@ -1,4 +1,4 @@
-Date,USD,JPY,BGN,CYP,CZK,DKK,EEK,GBP,HUF,LTL,LVL,MTL,PLN,ROL,RON,SEK,SIT,SKK,CHF,ISK,NOK,HRK,RUB,TRL,TRY,AUD,BRL,CAD,CNY,HKD,IDR,ILS,INR,KRW,MXN,MYR,NZD,PHP,SGD,THB,ZAR,
+Date,USD,JPY,BGN,CYP,CZK,DKK,EEK,GBP,HUF,LTL,LVL,MTL,PLN,ROL,RON,SEK,SIT,SKK,CHF,ISK,NOK,HRK,RUB,TRL,TRY,AUD,BRL,CAD,CNY,HKD,IDR,ILS,INR,KRW,MXN,MYR,NZD,PHP,SGD,THB,ZAR,
 2022-12-30,1.0666,140.66,1.9558,N/A,24.116,7.4365,N/A,0.88693,400.87,N/A,N/A,N/A,4.6808,N/A,4.9495,11.1218,N/A,N/A,0.9847,151.5,10.5138,7.5365,N/A,N/A,19.9649,1.5693,5.6386,1.444,7.3582,8.3163,16519.82,3.7554,88.171,1344.09,20.856,4.6984,1.6798,59.32,1.43,36.835,18.0986,
 2022-12-29,1.0649,142.24,1.9558,N/A,24.191,7.4365,N/A,0.88549,399.6,N/A,N/A,N/A,4.6855,N/A,4.9493,11.158,N/A,N/A,0.984,152.5,10.55,7.5365,N/A,N/A,19.934,1.5859,5.5351,1.4475,7.4151,8.2994,16680.38,3.7575,88.2295,1350.18,20.651,4.7106,1.6887,59.367,1.436,36.877,18.1967,
 2022-12-28,1.064,142.21,1.9558,N/A,24.252,7.4365,N/A,0.88058,403.3,N/A,N/A,N/A,4.7008,N/A,4.946,11.1038,N/A,N/A,0.9863,151.9,10.4495,7.5365,N/A,N/A,19.9144,1.566,5.6109,1.4361,7.4224,8.2931,16765.93,3.7526,88.0943,1348.59,20.6856,4.7055,1.6772,59.613,1.4323,36.953,18.289,

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

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

ext/fileio/fileio.go

@@ -0,0 +1,59 @@
+// Package fileio provides SQL functions to read, write and list files.
+//
+// https://sqlite.org/src/doc/tip/ext/misc/fileio.c
+package fileio
+
+import (
+	"errors"
+	"fmt"
+	"io/fs"
+	"os"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+// Register registers SQL functions readfile, writefile, lsmode,
+// and the table-valued function fsdir.
+func Register(db *sqlite3.Conn) {
+	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))
+	if fsys == nil {
+		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
+	})
+}
+
+func lsmode(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	ctx.ResultText(fs.FileMode(arg[0].Int()).String())
+}
+
+func readfile(fsys fs.FS) func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	return func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+		var err error
+		var data []byte
+
+		if fsys != nil {
+			data, err = fs.ReadFile(fsys, arg[0].Text())
+		} else {
+			data, err = os.ReadFile(arg[0].Text())
+		}
+
+		switch {
+		case err == nil:
+			ctx.ResultBlob(data)
+		case !errors.Is(err, fs.ErrNotExist):
+			ctx.ResultError(fmt.Errorf("readfile: %w", err))
+		}
+	}
+}

ext/fileio/fileio_test.go

@@ -0,0 +1,81 @@
+package fileio_test
+
+import (
+	"bytes"
+	"database/sql"
+	"io/fs"
+	"os"
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/driver"
+	_ "github.com/ncruces/go-sqlite3/embed"
+	"github.com/ncruces/go-sqlite3/ext/fileio"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+)
+
+func Test_lsmode(t *testing.T) {
+	t.Parallel()
+
+	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
+		fileio.Register(c)
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	d, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	s, err := os.Stat(d)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var mode string
+	err = db.QueryRow(`SELECT lsmode(?)`, s.Mode()).Scan(&mode)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(mode) != 10 || mode[0] != 'd' {
+		t.Errorf("got %s", mode)
+	} else {
+		t.Logf("got %s", mode)
+	}
+}
+
+func Test_readfile(t *testing.T) {
+	t.Parallel()
+
+	for _, fsys := range []fs.FS{nil, os.DirFS(".")} {
+		t.Run("", func(t *testing.T) {
+			db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
+				fileio.RegisterFS(c, fsys)
+				return nil
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer db.Close()
+
+			rows, err := db.Query(`SELECT readfile('fileio_test.go')`)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if rows.Next() {
+				var data sql.RawBytes
+				rows.Scan(&data)
+
+				if !bytes.HasPrefix(data, []byte("package fileio_test")) {
+					t.Errorf("got %s", data[:min(64, len(data))])
+				}
+			}
+		})
+	}
+}

ext/fileio/fsdir.go

@@ -0,0 +1,172 @@
+package fileio
+
+import (
+	"io/fs"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+type fsdir struct{ fsys fs.FS }
+
+func (d fsdir) BestIndex(idx *sqlite3.IndexInfo) error {
+	var root, base bool
+	for i, cst := range idx.Constraint {
+		switch cst.Column {
+		case 4: // root
+			if !cst.Usable || cst.Op != sqlite3.INDEX_CONSTRAINT_EQ {
+				return sqlite3.CONSTRAINT
+			}
+			idx.ConstraintUsage[i] = sqlite3.IndexConstraintUsage{
+				Omit:      true,
+				ArgvIndex: 1,
+			}
+			root = true
+		case 5: // base
+			if !cst.Usable || cst.Op != sqlite3.INDEX_CONSTRAINT_EQ {
+				return sqlite3.CONSTRAINT
+			}
+			idx.ConstraintUsage[i] = sqlite3.IndexConstraintUsage{
+				Omit:      true,
+				ArgvIndex: 2,
+			}
+			base = true
+		}
+	}
+	if !root {
+		return sqlite3.CONSTRAINT
+	}
+	if base {
+		idx.EstimatedCost = 10
+	} else {
+		idx.EstimatedCost = 100
+	}
+	return nil
+}
+
+func (d fsdir) Open() (sqlite3.VTabCursor, error) {
+	return &cursor{fsdir: d}, nil
+}
+
+type cursor struct {
+	fsdir
+	base   string
+	resume func(struct{}) (entry, bool)
+	cancel func()
+	curr   entry
+	eof    bool
+	rowID  int64
+}
+
+type entry struct {
+	fs.DirEntry
+	err  error
+	path string
+}
+
+func (c *cursor) Close() error {
+	if c.cancel != nil {
+		c.cancel()
+	}
+	return nil
+}
+
+func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
+	if err := c.Close(); err != nil {
+		return err
+	}
+
+	root := arg[0].Text()
+	if len(arg) > 1 {
+		base := arg[1].Text()
+		if c.fsys != nil {
+			root = path.Join(base, root)
+			base = path.Clean(base) + "/"
+		} else {
+			root = filepath.Join(base, root)
+			base = filepath.Clean(base) + string(filepath.Separator)
+		}
+		c.base = base
+	}
+
+	c.resume, c.cancel = coroNew(func(_ struct{}, yield func(entry) struct{}) entry {
+		walkDir := func(path string, d fs.DirEntry, err error) error {
+			yield(entry{d, err, path})
+			return nil
+		}
+		if c.fsys != nil {
+			fs.WalkDir(c.fsys, root, walkDir)
+		} else {
+			filepath.WalkDir(root, walkDir)
+		}
+		return entry{}
+	})
+	c.eof = false
+	c.rowID = 0
+	return c.Next()
+}
+
+func (c *cursor) Next() error {
+	curr, ok := c.resume(struct{}{})
+	c.curr = curr
+	c.eof = !ok
+	c.rowID++
+	return c.curr.err
+}
+
+func (c *cursor) EOF() bool {
+	return c.eof
+}
+
+func (c *cursor) RowID() (int64, error) {
+	return c.rowID, nil
+}
+
+func (c *cursor) Column(ctx *sqlite3.Context, n int) error {
+	switch n {
+	case 0: // name
+		name := strings.TrimPrefix(c.curr.path, c.base)
+		ctx.ResultText(name)
+
+	case 1: // mode
+		i, err := c.curr.Info()
+		if err != nil {
+			return err
+		}
+		ctx.ResultInt64(int64(i.Mode()))
+
+	case 2: // mtime
+		i, err := c.curr.Info()
+		if err != nil {
+			return err
+		}
+		ctx.ResultTime(i.ModTime(), sqlite3.TimeFormatUnixFrac)
+
+	case 3: // data
+		switch typ := c.curr.Type(); {
+		case typ.IsRegular():
+			var data []byte
+			var err error
+			if c.fsys != nil {
+				data, err = fs.ReadFile(c.fsys, c.curr.path)
+			} else {
+				data, err = os.ReadFile(c.curr.path)
+			}
+			if err != nil {
+				return err
+			}
+			ctx.ResultBlob(data)
+
+		case typ&fs.ModeSymlink != 0 && c.fsys == nil:
+			t, err := os.Readlink(c.curr.path)
+			if err != nil {
+				return err
+			}
+			ctx.ResultText(t)
+		}
+	}
+	return nil
+}

ext/fileio/fsdir_test.go

@@ -0,0 +1,79 @@
+package fileio_test
+
+import (
+	"bytes"
+	"database/sql"
+	"io/fs"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/driver"
+	_ "github.com/ncruces/go-sqlite3/embed"
+	"github.com/ncruces/go-sqlite3/ext/fileio"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+)
+
+func Test_fsdir(t *testing.T) {
+	t.Parallel()
+
+	for _, fsys := range []fs.FS{nil, os.DirFS(".")} {
+		t.Run("", func(t *testing.T) {
+			db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
+				fileio.RegisterFS(c, fsys)
+				return nil
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer db.Close()
+
+			rows, err := db.Query(`SELECT * FROM fsdir('.', '.')`)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			for rows.Next() {
+				var name string
+				var mode fs.FileMode
+				var mtime time.Time
+				var data sql.RawBytes
+				err := rows.Scan(&name, &mode, sqlite3.TimeFormatUnixFrac.Scanner(&mtime), &data)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if mode.Perm() == 0 {
+					t.Errorf("got: %v", mode)
+				}
+				if mtime.Before(time.Unix(0, 0)) {
+					t.Errorf("got: %v", mtime)
+				}
+				if name == "fsdir_test.go" {
+					if !bytes.HasPrefix(data, []byte("package fileio_test")) {
+						t.Errorf("got: %s", data[:min(64, len(data))])
+					}
+				}
+			}
+		})
+	}
+}
+
+func Test_fsdir_errors(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	fileio.Register(db)
+
+	err = db.Exec(`SELECT name FROM fsdir()`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+}

ext/fileio/write.go

@@ -0,0 +1,97 @@
+package fileio
+
+import (
+	"errors"
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/ncruces/go-sqlite3/util/fsutil"
+)
+
+func writefile(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	if len(arg) < 2 || len(arg) > 4 {
+		ctx.ResultError(util.ErrorString("writefile: wrong number of arguments"))
+		return
+	}
+
+	file := arg[0].Text()
+
+	var mode fs.FileMode
+	if len(arg) > 2 {
+		mode = fsutil.FileModeFromValue(arg[2])
+	}
+
+	n, err := createFileAndDir(file, mode, arg[1])
+	if err != nil {
+		if len(arg) > 2 {
+			ctx.ResultError(fmt.Errorf("writefile: %w", err))
+		}
+		return
+	}
+
+	if mode&fs.ModeSymlink == 0 {
+		if len(arg) > 2 {
+			err := os.Chmod(file, mode.Perm())
+			if err != nil {
+				ctx.ResultError(fmt.Errorf("writefile: %w", err))
+				return
+			}
+		}
+
+		if len(arg) > 3 {
+			mtime := arg[3].Time(sqlite3.TimeFormatUnixFrac)
+			err := os.Chtimes(file, time.Time{}, mtime)
+			if err != nil {
+				ctx.ResultError(fmt.Errorf("writefile: %w", err))
+				return
+			}
+		}
+	}
+
+	if mode.IsRegular() {
+		ctx.ResultInt(n)
+	}
+}
+
+func createFileAndDir(path string, mode fs.FileMode, data sqlite3.Value) (int, error) {
+	n, err := createFile(path, mode, data)
+	if errors.Is(err, fs.ErrNotExist) {
+		if err := os.MkdirAll(filepath.Dir(path), 0777); err == nil {
+			return createFile(path, mode, data)
+		}
+	}
+	return n, err
+}
+
+func createFile(path string, mode fs.FileMode, data sqlite3.Value) (int, error) {
+	if mode.IsRegular() {
+		blob := data.RawBlob()
+		return len(blob), os.WriteFile(path, blob, fixPerm(mode, 0666))
+	}
+	if mode.IsDir() {
+		err := os.Mkdir(path, fixPerm(mode, 0777))
+		if errors.Is(err, fs.ErrExist) {
+			s, err := os.Lstat(path)
+			if err == nil && s.IsDir() {
+				return 0, nil
+			}
+		}
+		return 0, err
+	}
+	if mode&fs.ModeSymlink != 0 {
+		return 0, os.Symlink(data.Text(), path)
+	}
+	return 0, fmt.Errorf("invalid mode: %v", mode)
+}
+
+func fixPerm(mode fs.FileMode, def fs.FileMode) fs.FileMode {
+	if mode.Perm() == 0 {
+		return def
+	}
+	return mode.Perm()
+}

ext/fileio/write_test.go

@@ -0,0 +1,93 @@
+package fileio
+
+import (
+	"database/sql"
+	"io/fs"
+	"path/filepath"
+	"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"
+)
+
+func Test_writefile(t *testing.T) {
+	t.Parallel()
+
+	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
+		Register(c)
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	dir := t.TempDir()
+	link := filepath.Join(dir, "link")
+	file := filepath.Join(dir, "test.txt")
+	nest := filepath.Join(dir, "tmp", "test.txt")
+	sock := filepath.Join(dir, "sock")
+	twosday := time.Date(2022, 2, 22, 22, 22, 22, 0, time.UTC)
+
+	_, err = db.Exec(`SELECT writefile(?, 'Hello world!')`, file)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = db.Exec(`SELECT writefile(?, ?, ?)`, link, "test.txt", fs.ModeSymlink)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = db.Exec(`SELECT writefile(?, ?, ?, ?)`, dir, nil, 0040700, twosday.Unix())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	rows, err := db.Query(`SELECT * FROM fsdir('.', ?)`, dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for rows.Next() {
+		var name string
+		var mode fs.FileMode
+		var mtime time.Time
+		var data sql.NullString
+		err := rows.Scan(&name, &mode, &mtime, &data)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if mode.IsDir() && !mtime.Equal(twosday) {
+			t.Errorf("got: %v", mtime)
+		}
+		if mode.IsRegular() && data.String != "Hello world!" {
+			t.Errorf("got: %v", data)
+		}
+		if mode&fs.ModeSymlink != 0 && data.String != "test.txt" {
+			t.Errorf("got: %v", data)
+		}
+	}
+
+	_, err = db.Exec(`SELECT writefile(?, 'Hello world!')`, nest)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = db.Exec(`SELECT writefile(?, ?, ?)`, sock, nil, fs.ModeSocket)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	_, err = db.Exec(`SELECT writefile()`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+}

ext/hash/blake2.go

@@ -0,0 +1,30 @@
+package hash
+
+import (
+	"crypto"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
+)
+
+func blake2sFunc(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	hashFunc(ctx, arg[0], crypto.BLAKE2s_256)
+}
+
+func blake2bFunc(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	size := 512
+	if len(arg) > 1 {
+		size = arg[1].Int()
+	}
+
+	switch size {
+	case 256:
+		hashFunc(ctx, arg[0], crypto.BLAKE2b_256)
+	case 384:
+		hashFunc(ctx, arg[0], crypto.BLAKE2b_384)
+	case 512:
+		hashFunc(ctx, arg[0], crypto.BLAKE2b_512)
+	default:
+		ctx.ResultError(util.ErrorString("blake2b: size must be 256, 384, 512"))
+	}
+}

ext/hash/hash.go

@@ -0,0 +1,97 @@
+// Package hash provides cryptographic hash functions.
+//
+// Provided functions:
+//   - md4(data)
+//   - md5(data)
+//   - sha1(data)
+//   - sha3(data, size) (default size 256)
+//   - sha224(data)
+//   - sha256(data, size) (default size 256)
+//   - sha384(data)
+//   - sha512(data, size) (default size 512)
+//   - blake2s(data)
+//   - blake2b(data, size) (default size 512)
+//   - ripemd160(data)
+//
+// Each SQL function will only be registered if the corresponding
+// [crypto.Hash] function is available.
+// To ensure a specific hash function is available,
+// import the implementing package.
+package hash
+
+import (
+	"crypto"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+// Register registers cryptographic hash functions for a database connection.
+func Register(db *sqlite3.Conn) {
+	flags := sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
+
+	if crypto.MD4.Available() {
+		db.CreateFunction("md4", 1, flags, md4Func)
+	}
+	if crypto.MD5.Available() {
+		db.CreateFunction("md5", 1, flags, md5Func)
+	}
+	if crypto.SHA1.Available() {
+		db.CreateFunction("sha1", 1, flags, sha1Func)
+	}
+	if crypto.SHA3_512.Available() {
+		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)
+	}
+	if crypto.SHA512.Available() {
+		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)
+	}
+	if crypto.BLAKE2b_512.Available() {
+		db.CreateFunction("blake2b", 1, flags, blake2bFunc)
+		db.CreateFunction("blake2b", 2, flags, blake2bFunc)
+	}
+	if crypto.RIPEMD160.Available() {
+		db.CreateFunction("ripemd160", 1, flags, ripemd160Func)
+	}
+}
+
+func md4Func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	hashFunc(ctx, arg[0], crypto.MD4)
+}
+
+func md5Func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	hashFunc(ctx, arg[0], crypto.MD5)
+}
+
+func sha1Func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	hashFunc(ctx, arg[0], crypto.SHA1)
+}
+
+func ripemd160Func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	hashFunc(ctx, arg[0], crypto.RIPEMD160)
+}
+
+func hashFunc(ctx sqlite3.Context, arg sqlite3.Value, fn crypto.Hash) {
+	var data []byte
+	switch arg.Type() {
+	case sqlite3.NULL:
+		return
+	case sqlite3.BLOB:
+		data = arg.RawBlob()
+	default:
+		data = arg.RawText()
+	}
+
+	h := fn.New()
+	h.Write(data)
+	ctx.ResultBlob(h.Sum(nil))
+}

ext/hash/hash_test.go

@@ -0,0 +1,99 @@
+package hash
+
+import (
+	_ "crypto/md5"
+	_ "crypto/sha1"
+	_ "crypto/sha256"
+	_ "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"
+	_ "golang.org/x/crypto/blake2b"
+	_ "golang.org/x/crypto/blake2s"
+	_ "golang.org/x/crypto/md4"
+	_ "golang.org/x/crypto/ripemd160"
+	_ "golang.org/x/crypto/sha3"
+)
+
+func TestRegister(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		hash string
+	}{
+		{"md4(NULL)", ""},
+		{"md4(X'')", "31D6CFE0D16AE931B73C59D7E0C089C0"},
+		{"md4('The quick brown fox jumps over the lazy dog')", "1BEE69A46BA811185C194762ABAEAE90"},
+
+		{"md5('')", "D41D8CD98F00B204E9800998ECF8427E"},
+		{"sha1('')", "DA39A3EE5E6B4B0D3255BFEF95601890AFD80709"},
+		{"ripemd160('')", "9C1185A5C5E9FC54612808977EE8F548B2258D31"},
+
+		{"sha224('')", "D14A028C2A3A2BC9476102BB288234C415A2B01F828EA62AC5B3E42F"},
+		{"sha256('')", "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"},
+		{"sha256('', 224)", "D14A028C2A3A2BC9476102BB288234C415A2B01F828EA62AC5B3E42F"},
+		{"sha384('')", "38B060A751AC96384CD9327EB1B1E36A21FDB71114BE07434C0CC7BF63F6E1DA274EDEBFE76F65FBD51AD2F14898B95B"},
+		{"sha512('')", "CF83E1357EEFB8BDF1542850D66D8007D620E4050B5715DC83F4A921D36CE9CE47D0D13C5D85F2B0FF8318D2877EEC2F63B931BD47417A81A538327AF927DA3E"},
+		{"sha512('', 224)", "6ED0DD02806FA89E25DE060C19D3AC86CABB87D6A0DDD05C333B84F4"},
+		{"sha512('', 256)", "C672B8D1EF56ED28AB87C3622C5114069BDD3AD7B8F9737498D0C01ECEF0967A"},
+		{"sha512('', 384)", "38B060A751AC96384CD9327EB1B1E36A21FDB71114BE07434C0CC7BF63F6E1DA274EDEBFE76F65FBD51AD2F14898B95B"},
+
+		{"sha3('')", "A7FFC6F8BF1ED76651C14756A061D662F580FF4DE43B49FA82D80A4B80F8434A"},
+		{"sha3('', 224)", "6B4E03423667DBB73B6E15454F0EB1ABD4597F9A1B078E3F5B5A6BC7"},
+		{"sha3('', 384)", "0C63A75B845E4F7D01107D852E4C2485C51A50AAAA94FC61995E71BBEE983A2AC3713831264ADB47FB6BD1E058D5F004"},
+		{"sha3('', 512)", "A69F73CCA23A9AC5C8B567DC185A756E97C982164FE25859E0D1DCC1475C80A615B2123AF1F5F94C11E3E9402C3AC558F500199D95B6D3E301758586281DCD26"},
+
+		{"blake2s('')", "69217A3079908094E11121D042354A7C1F55B6482CA1A51E1B250DFD1ED0EEF9"},
+		{"blake2b('')", "786A02F742015903C6C6FD852552D272912F4740E15847618A86E217F71F5419D25E1031AFEE585313896444934EB04B903A685B1448B755D56F701AFE9BE2CE"},
+		{"blake2b('', 384)", "B32811423377F52D7862286EE1A72EE540524380FDA1724A6F25D7978C6FD3244A6CAF0498812673C5E05EF583825100"},
+		{"blake2b('', 256)", "0E5751C026E543B2E8AB2EB06099DAA1D1E5DF47778F7787FAAB45CDF12FE3A8"},
+	}
+
+	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
+		Register(c)
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var hash string
+
+			err = db.QueryRow(`SELECT hex(` + tt.name + `)`).Scan(&hash)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if hash != tt.hash {
+				t.Errorf("got %s, want %s", hash, tt.hash)
+			}
+		})
+	}
+
+	_, err = db.Exec(`SELECT sha256('', 255)`)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	_, err = db.Exec(`SELECT sha512('', 255)`)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	_, err = db.Exec(`SELECT sha3('', 255)`)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	_, err = db.Exec(`SELECT blake2b('', 255)`)
+	if err == nil {
+		t.Error("want error")
+	}
+}

ext/hash/sha2.go

@@ -0,0 +1,53 @@
+package hash
+
+import (
+	"crypto"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
+)
+
+func sha224Func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	hashFunc(ctx, arg[0], crypto.SHA224)
+}
+
+func sha384Func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	hashFunc(ctx, arg[0], crypto.SHA384)
+}
+
+func sha256Func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	size := 256
+	if len(arg) > 1 {
+		size = arg[1].Int()
+	}
+
+	switch size {
+	case 224:
+		hashFunc(ctx, arg[0], crypto.SHA224)
+	case 256:
+		hashFunc(ctx, arg[0], crypto.SHA256)
+	default:
+		ctx.ResultError(util.ErrorString("sha256: size must be 224, 256"))
+	}
+}
+
+func sha512Func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	size := 512
+	if len(arg) > 1 {
+		size = arg[1].Int()
+	}
+
+	switch size {
+	case 224:
+		hashFunc(ctx, arg[0], crypto.SHA512_224)
+	case 256:
+		hashFunc(ctx, arg[0], crypto.SHA512_256)
+	case 384:
+		hashFunc(ctx, arg[0], crypto.SHA384)
+	case 512:
+		hashFunc(ctx, arg[0], crypto.SHA512)
+	default:
+		ctx.ResultError(util.ErrorString("sha512: size must be 224, 256, 384, 512"))
+	}
+
+}

ext/hash/sha3.go

@@ -0,0 +1,28 @@
+package hash
+
+import (
+	"crypto"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
+)
+
+func sha3Func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	size := 256
+	if len(arg) > 1 {
+		size = arg[1].Int()
+	}
+
+	switch size {
+	case 224:
+		hashFunc(ctx, arg[0], crypto.SHA3_224)
+	case 256:
+		hashFunc(ctx, arg[0], crypto.SHA3_256)
+	case 384:
+		hashFunc(ctx, arg[0], crypto.SHA3_384)
+	case 512:
+		hashFunc(ctx, arg[0], crypto.SHA3_512)
+	default:
+		ctx.ResultError(util.ErrorString("sha3: size must be 224, 256, 384, 512"))
+	}
+}

ext/lines/lines.go

@@ -1,4 +1,13 @@
-// Package lines provides a virtual table to read large files line-by-line.
+// Package lines provides a virtual table to read data line-by-line.
+//
+// It is particularly useful for line-oriented datasets,
+// like [ndjson] or [JSON Lines],
+// when paired with SQLite's JSON support.
+//
+// https://github.com/asg017/sqlite-lines
+//
+// [ndjson]: https://ndjson.org/
+// [JSON Lines]: https://jsonlines.org/
 package lines
 
 import (
@@ -6,31 +15,42 @@ import (
 	"bytes"
 	"fmt"
 	"io"
-	"math"
-	"os"
+	"io/fs"
 
 	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/util/osutil"
 )
 
-// Register registers the lines and lines_read virtual tables.
-// The lines virtual table reads from a database blob or text.
-// The lines_read virtual table reads from a file or an [io.ReaderAt].
+// Register 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, [os.Open] is used to open the file.
 func Register(db *sqlite3.Conn) {
-	sqlite3.CreateModule[lines](db, "lines", nil,
-		func(db *sqlite3.Conn, arg ...string) (lines, error) {
-			err := db.DeclareVtab(`CREATE TABLE x(line TEXT, data HIDDEN)`)
-			db.VtabConfig(sqlite3.VTAB_INNOCUOUS)
-			return false, err
+	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(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, arg ...string) (lines, error) {
-			err := db.DeclareVtab(`CREATE TABLE x(line TEXT, data HIDDEN)`)
-			db.VtabConfig(sqlite3.VTAB_DIRECTONLY)
-			return true, 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 bool
+type lines struct {
+	fsys fs.FS
+}
 
 func (l lines) BestIndex(idx *sqlite3.IndexInfo) error {
 	for i, cst := range idx.Constraint {
@@ -48,74 +68,126 @@ func (l lines) BestIndex(idx *sqlite3.IndexInfo) error {
 }
 
 func (l lines) Open() (sqlite3.VTabCursor, error) {
-	return &cursor{reader: bool(l)}, nil
+	if l.fsys != nil {
+		return &reader{fsys: l.fsys}, nil
+	} else {
+		return &buffer{}, nil
+	}
 }
 
 type cursor struct {
-	reader  bool
-	scanner *bufio.Scanner
-	closer  io.Closer
-	rowID   int64
-	eof     bool
-}
-
-func (c *cursor) Close() (err error) {
-	if c.closer != nil {
-		err = c.closer.Close()
-		c.closer = nil
-	}
-	return err
+	line  []byte
+	rowID int64
+	eof   bool
 }
 
 func (c *cursor) EOF() bool {
 	return c.eof
 }
 
-func (c *cursor) Next() error {
-	c.rowID++
-	c.eof = !c.scanner.Scan()
-	return c.scanner.Err()
-}
-
 func (c *cursor) RowID() (int64, error) {
 	return c.rowID, nil
 }
 
 func (c *cursor) Column(ctx *sqlite3.Context, n int) error {
 	if n == 0 {
-		ctx.ResultRawText(c.scanner.Bytes())
+		ctx.ResultRawText(c.line)
 	}
 	return nil
 }
 
-func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
+type reader struct {
+	fsys   fs.FS
+	reader *bufio.Reader
+	closer io.Closer
+	cursor
+}
+
+func (c *reader) Close() (err error) {
+	if c.closer != nil {
+		err = c.closer.Close()
+		c.closer = nil
+	}
+	return err
+}
+
+func (c *reader) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
 	if err := c.Close(); err != nil {
 		return err
 	}
 
 	var r io.Reader
-	data := arg[0]
-	if c.reader {
-		if data.Type() == sqlite3.NULL {
-			if p, ok := data.Pointer().(io.ReaderAt); ok {
-				r = io.NewSectionReader(p, 0, math.MaxInt64)
-			}
-		} else {
-			f, err := os.Open(data.Text())
-			if err != nil {
-				return err
-			}
-			c.closer = f
-			r = f
+	typ := arg[0].Type()
+	switch typ {
+	case sqlite3.NULL:
+		if p, ok := arg[0].Pointer().(io.Reader); ok {
+			r = p
 		}
-	} else if data.Type() != sqlite3.NULL {
-		r = bytes.NewReader(data.RawBlob())
+	case sqlite3.TEXT:
+		f, err := c.fsys.Open(arg[0].Text())
+		if err != nil {
+			return err
+		}
+		r = f
+	}
+	if r == nil {
+		return fmt.Errorf("lines: unsupported argument:%.0w %v", sqlite3.MISMATCH, typ)
 	}
 
-	if r == nil {
-		return fmt.Errorf("lines: unsupported argument:%.0w %v", sqlite3.MISMATCH, data.Type())
-	}
-	c.scanner = bufio.NewScanner(r)
+	c.reader = bufio.NewReader(r)
+	c.closer, _ = r.(io.Closer)
 	c.rowID = 0
 	return c.Next()
 }
+
+func (c *reader) Next() (err error) {
+	c.line = c.line[:0]
+	for more := true; more; {
+		var line []byte
+		line, more, err = c.reader.ReadLine()
+		c.line = append(c.line, line...)
+	}
+	if err == io.EOF {
+		c.eof = true
+		err = nil
+	}
+	c.rowID++
+	return err
+}
+
+type buffer struct {
+	data []byte
+	cursor
+}
+
+func (c *buffer) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
+	typ := arg[0].Type()
+	switch typ {
+	case sqlite3.TEXT:
+		c.data = arg[0].RawText()
+	case sqlite3.BLOB:
+		c.data = arg[0].RawBlob()
+	default:
+		return fmt.Errorf("lines: unsupported argument:%.0w %v", sqlite3.MISMATCH, typ)
+	}
+
+	c.rowID = 0
+	return c.Next()
+}
+
+func (c *buffer) Next() error {
+	i := bytes.IndexByte(c.data, '\n')
+	j := i + 1
+	switch {
+	case i < 0:
+		i = len(c.data)
+		j = i
+	case i > 0 && c.data[i-1] == '\r':
+		i--
+	}
+	c.eof = len(c.data) == 0
+	c.line = c.data[:i]
+	c.data = c.data[j:]
+	c.rowID++
+	return nil
+}

ext/lines/lines_test.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"log"
+	"net/http"
 	"os"
 	"strings"
 	"testing"
@@ -13,6 +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/internal/testcfg"
 )
 
 func Example() {
@@ -25,12 +27,11 @@ func Example() {
 	}
 	defer db.Close()
 
-	// https://storage.googleapis.com/quickdraw_dataset/full/simplified/calendar.ndjson
-	f, err := os.Open("calendar.ndjson")
+	res, err := http.Get("https://storage.googleapis.com/quickdraw_dataset/full/simplified/calendar.ndjson")
 	if err != nil {
 		log.Fatal(err)
 	}
-	defer f.Close()
+	defer res.Body.Close()
 
 	rows, err := db.Query(`
 		SELECT
@@ -40,7 +41,7 @@ func Example() {
   		GROUP BY 1
   		ORDER BY 2 DESC
   		LIMIT 5`,
-		sqlite3.Pointer(f))
+		sqlite3.Pointer(res.Body))
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -58,7 +59,7 @@ func Example() {
 	if err := rows.Err(); err != nil {
 		log.Fatal(err)
 	}
-	// Sample output:
+	// Expected output:
 	// US: 141001
 	// GB: 22560
 	// CA: 11759
@@ -67,6 +68,8 @@ 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
@@ -76,7 +79,7 @@ func Test_lines(t *testing.T) {
 	}
 	defer db.Close()
 
-	const data = "line 1\nline 2\nline 3"
+	const data = "line 1\nline 2\r\nline 3\n"
 
 	rows, err := db.Query(`SELECT rowid, line FROM lines(?)`, data)
 	if err != nil {
@@ -91,10 +94,15 @@ func Test_lines(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
+		if want := fmt.Sprintf("line %d", id); line != want {
+			t.Errorf("got %q, want %q", line, want)
+		}
 	}
 }
 
 func Test_lines_error(t *testing.T) {
+	t.Parallel()
+
 	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
 		lines.Register(c)
 		return nil
@@ -120,6 +128,8 @@ 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
@@ -129,7 +139,7 @@ func Test_lines_read(t *testing.T) {
 	}
 	defer db.Close()
 
-	const data = "line 1\nline 2\nline 3"
+	const data = "line 1\nline 2\r\nline 3\n"
 
 	rows, err := db.Query(`SELECT rowid, line FROM lines_read(?)`,
 		sqlite3.Pointer(strings.NewReader(data)))
@@ -145,10 +155,15 @@ func Test_lines_read(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
+		if want := fmt.Sprintf("line %d", id); line != want {
+			t.Errorf("got %q, want %q", line, want)
+		}
 	}
 }
 
 func Test_lines_test(t *testing.T) {
+	t.Parallel()
+
 	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
 		lines.Register(c)
 		return nil

ext/pivot/op_test.go

@@ -0,0 +1,34 @@
+package pivot
+
+import (
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+func Test_operator(t *testing.T) {
+	tests := []struct {
+		op   sqlite3.IndexConstraintOp
+		want string
+	}{
+		{sqlite3.INDEX_CONSTRAINT_EQ, "="},
+		{sqlite3.INDEX_CONSTRAINT_LT, "<"},
+		{sqlite3.INDEX_CONSTRAINT_GT, ">"},
+		{sqlite3.INDEX_CONSTRAINT_LE, "<="},
+		{sqlite3.INDEX_CONSTRAINT_GE, ">="},
+		{sqlite3.INDEX_CONSTRAINT_NE, "<>"},
+		{sqlite3.INDEX_CONSTRAINT_IS, "IS"},
+		{sqlite3.INDEX_CONSTRAINT_ISNOT, "IS NOT"},
+		{sqlite3.INDEX_CONSTRAINT_REGEXP, "REGEXP"},
+		{sqlite3.INDEX_CONSTRAINT_MATCH, "MATCH"},
+		{sqlite3.INDEX_CONSTRAINT_GLOB, "GLOB"},
+		{sqlite3.INDEX_CONSTRAINT_LIKE, "LIKE"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.want, func(t *testing.T) {
+			if got := operator(tt.op); got != tt.want {
+				t.Errorf("operator() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

ext/pivot/pivot.go

@@ -0,0 +1,274 @@
+// Package pivot implements a pivot virtual table.
+//
+// https://github.com/jakethaw/pivot_vtab
+package pivot
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+// Register registers the pivot virtual table.
+func Register(db *sqlite3.Conn) {
+	sqlite3.CreateModule(db, "pivot", declare, declare)
+}
+
+type table struct {
+	db   *sqlite3.Conn
+	scan string
+	cell string
+	keys []string
+	cols []*sqlite3.Value
+}
+
+func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (_ *table, err error) {
+	if len(arg) != 3 {
+		return nil, fmt.Errorf("pivot: wrong number of arguments")
+	}
+
+	table := &table{db: db}
+	defer func() {
+		if err != nil {
+			table.Close()
+		}
+	}()
+
+	var sep string
+	var create strings.Builder
+	create.WriteString("CREATE TABLE x(")
+
+	// Row key query.
+	table.scan = "SELECT * FROM\n" + arg[0]
+	stmt, _, err := db.Prepare(table.scan)
+	if err != nil {
+		return nil, err
+	}
+	defer stmt.Close()
+
+	table.keys = make([]string, stmt.ColumnCount())
+	for i := range table.keys {
+		name := sqlite3.QuoteIdentifier(stmt.ColumnName(i))
+		table.keys[i] = name
+		create.WriteString(sep)
+		create.WriteString(name)
+		sep = ","
+	}
+	stmt.Close()
+
+	// Column definition query.
+	stmt, _, err = db.Prepare("SELECT * FROM\n" + arg[1])
+	if err != nil {
+		return nil, err
+	}
+
+	if stmt.ColumnCount() != 2 {
+		return nil, errors.New("pivot: column definition query expects 2 result columns")
+	}
+	for stmt.Step() {
+		name := sqlite3.QuoteIdentifier(stmt.ColumnText(1))
+		table.cols = append(table.cols, stmt.ColumnValue(0).Dup())
+		create.WriteString(",")
+		create.WriteString(name)
+	}
+	stmt.Close()
+
+	// Pivot cell query.
+	table.cell = "SELECT * FROM\n" + arg[2]
+	stmt, _, err = db.Prepare(table.cell)
+	if err != nil {
+		return nil, err
+	}
+
+	if stmt.ColumnCount() != 1 {
+		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)
+	}
+
+	create.WriteByte(')')
+	err = db.DeclareVTab(create.String())
+	if err != nil {
+		return nil, err
+	}
+	return table, nil
+}
+
+func (t *table) Close() error {
+	for i := range t.cols {
+		t.cols[i].Close()
+	}
+	return nil
+}
+
+func (t *table) BestIndex(idx *sqlite3.IndexInfo) error {
+	var idxStr strings.Builder
+	idxStr.WriteString(t.scan)
+
+	argvIndex := 1
+	sep := " WHERE "
+	for i, cst := range idx.Constraint {
+		if !cst.Usable || !(0 <= cst.Column && cst.Column < len(t.keys)) {
+			continue
+		}
+		op := operator(cst.Op)
+		if op == "" {
+			continue
+		}
+
+		idxStr.WriteString(sep)
+		idxStr.WriteString(t.keys[cst.Column])
+		idxStr.WriteString(" ")
+		idxStr.WriteString(op)
+		idxStr.WriteString(" ?")
+
+		idx.ConstraintUsage[i] = sqlite3.IndexConstraintUsage{
+			ArgvIndex: argvIndex,
+			Omit:      true,
+		}
+		sep = " AND "
+		argvIndex++
+	}
+
+	sep = " ORDER BY "
+	idx.OrderByConsumed = true
+	for _, ord := range idx.OrderBy {
+		if !(0 <= ord.Column && ord.Column < len(t.keys)) {
+			idx.OrderByConsumed = false
+			continue
+		}
+		idxStr.WriteString(sep)
+		idxStr.WriteString(t.keys[ord.Column])
+		idxStr.WriteString(" COLLATE ")
+		idxStr.WriteString(idx.Collation(ord.Column))
+		if ord.Desc {
+			idxStr.WriteString(" DESC")
+		}
+		sep = ","
+	}
+
+	idx.EstimatedCost = 1e9 / float64(argvIndex)
+	idx.IdxStr = idxStr.String()
+	return nil
+}
+
+func (t *table) Open() (sqlite3.VTabCursor, error) {
+	return &cursor{table: t}, nil
+}
+
+func (t *table) Rename(new string) error {
+	return nil
+}
+
+type cursor struct {
+	table *table
+	scan  *sqlite3.Stmt
+	cell  *sqlite3.Stmt
+	rowID int64
+}
+
+func (c *cursor) Close() error {
+	return errors.Join(c.scan.Close(), c.cell.Close())
+}
+
+func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
+	err := c.scan.Close()
+	if err != nil {
+		return err
+	}
+
+	c.scan, _, err = c.table.db.Prepare(idxStr)
+	if err != nil {
+		return err
+	}
+	for i, arg := range arg {
+		err := c.scan.BindValue(i+1, arg)
+		if err != nil {
+			return err
+		}
+	}
+
+	if c.cell == nil {
+		c.cell, _, err = c.table.db.Prepare(c.table.cell)
+		if err != nil {
+			return err
+		}
+	}
+
+	c.rowID = 0
+	return c.Next()
+}
+
+func (c *cursor) Next() error {
+	if c.scan.Step() {
+		count := c.scan.ColumnCount()
+		for i := 0; i < count; i++ {
+			err := c.cell.BindValue(i+1, c.scan.ColumnValue(i))
+			if err != nil {
+				return err
+			}
+		}
+		c.rowID++
+	}
+	return c.scan.Err()
+}
+
+func (c *cursor) EOF() bool {
+	return !c.scan.Busy()
+}
+
+func (c *cursor) RowID() (int64, error) {
+	return c.rowID, nil
+}
+
+func (c *cursor) Column(ctx *sqlite3.Context, col int) error {
+	count := c.scan.ColumnCount()
+	if col < count {
+		ctx.ResultValue(c.scan.ColumnValue(col))
+		return nil
+	}
+
+	err := c.cell.BindValue(count+1, *c.table.cols[col-count])
+	if err != nil {
+		return err
+	}
+
+	if c.cell.Step() {
+		ctx.ResultValue(c.cell.ColumnValue(0))
+	}
+	return c.cell.Reset()
+}
+
+func operator(op sqlite3.IndexConstraintOp) string {
+	switch op {
+	case sqlite3.INDEX_CONSTRAINT_EQ:
+		return "="
+	case sqlite3.INDEX_CONSTRAINT_LT:
+		return "<"
+	case sqlite3.INDEX_CONSTRAINT_GT:
+		return ">"
+	case sqlite3.INDEX_CONSTRAINT_LE:
+		return "<="
+	case sqlite3.INDEX_CONSTRAINT_GE:
+		return ">="
+	case sqlite3.INDEX_CONSTRAINT_NE:
+		return "<>"
+	case sqlite3.INDEX_CONSTRAINT_MATCH:
+		return "MATCH"
+	case sqlite3.INDEX_CONSTRAINT_LIKE:
+		return "LIKE"
+	case sqlite3.INDEX_CONSTRAINT_GLOB:
+		return "GLOB"
+	case sqlite3.INDEX_CONSTRAINT_REGEXP:
+		return "REGEXP"
+	case sqlite3.INDEX_CONSTRAINT_IS, sqlite3.INDEX_CONSTRAINT_ISNULL:
+		return "IS"
+	case sqlite3.INDEX_CONSTRAINT_ISNOT, sqlite3.INDEX_CONSTRAINT_ISNOTNULL:
+		return "IS NOT"
+	default:
+		return ""
+	}
+}

ext/pivot/pivot_test.go

@@ -0,0 +1,220 @@
+package pivot_test
+
+import (
+	"fmt"
+	"log"
+	"strings"
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+	_ "github.com/ncruces/go-sqlite3/embed"
+	"github.com/ncruces/go-sqlite3/ext/pivot"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+)
+
+// https://antonz.org/sqlite-pivot-table/
+func Example() {
+	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
+			('alpha', 2020, 100),
+			('alpha', 2021, 120),
+			('alpha', 2022, 130),
+			('alpha', 2023, 140),
+			('beta',  2020, 10),
+			('beta',  2021, 20),
+			('beta',  2022, 40),
+			('beta',  2023, 80),
+			('gamma', 2020, 80),
+			('gamma', 2021, 75),
+			('gamma', 2022, 78),
+			('gamma', 2023, 80);
+	`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = db.Exec(`
+		CREATE VIRTUAL TABLE v_sales USING pivot(
+			-- rows
+			(SELECT DISTINCT product FROM sales),
+			-- columns
+			(SELECT DISTINCT year, year FROM sales),
+			-- cells
+			(SELECT sum(income) FROM sales WHERE product = ? AND year = ?)
+		)`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT * FROM v_sales`)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer stmt.Close()
+
+	cols := make([]string, stmt.ColumnCount())
+	for i := range cols {
+		cols[i] = stmt.ColumnName(i)
+	}
+	fmt.Println(pretty(cols))
+	for stmt.Step() {
+		for i := range cols {
+			cols[i] = stmt.ColumnText(i)
+		}
+		fmt.Println(pretty(cols))
+	}
+	if err := stmt.Reset(); err != nil {
+		log.Fatal(err)
+	}
+
+	// Output:
+	// product 2020    2021    2022    2023
+	// alpha   100     120     130     140
+	// beta    10      20      40      80
+	// gamma   80      75      78      80
+}
+
+func TestRegister(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	pivot.Register(db)
+
+	err = db.Exec(`
+		CREATE TABLE r AS
+			SELECT 1 id UNION SELECT 2 UNION SELECT 3;
+
+		CREATE TABLE c(
+			id   INTEGER PRIMARY KEY,
+			name TEXT
+		);
+		INSERT INTO c (name) VALUES
+			('a'),('b'),('c'),('d');
+
+		CREATE TABLE x(
+			r_id INT,
+			c_id INT,
+			val  TEXT
+		);
+		INSERT INTO x (r_id, c_id, val)
+			SELECT r.id, c.id, c.name || r.id
+			FROM c, r;				
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`
+		CREATE VIRTUAL TABLE v_x USING pivot(
+			-- rows
+			(SELECT id r_id FROM r),
+			-- columns
+			(SELECT id c_id, name FROM c),
+			-- cells
+			(SELECT val FROM x WHERE r_id = ?1 AND c_id = ?2)
+		)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT * FROM v_x WHERE rowid <> 0 AND r_id <> 1 ORDER BY rowid, r_id DESC LIMIT 1`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer stmt.Close()
+
+	if stmt.Step() {
+		if got := stmt.ColumnInt(0); got != 3 {
+			t.Errorf("got %d, want 3", got)
+		}
+	}
+}
+
+func TestRegister_errors(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	pivot.Register(db)
+
+	err = db.Exec(`CREATE VIRTUAL TABLE pivot USING pivot()`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE split_date USING pivot(SELECT 1, SELECT 2, SELECT 3)`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE split_date USING pivot((SELECT 1), SELECT 2, SELECT 3)`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE split_date USING pivot((SELECT 1), (SELECT 2), SELECT 3)`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE split_date USING pivot((SELECT 1), (SELECT 1, 2), SELECT 3)`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE split_date USING pivot((SELECT 1), (SELECT 1, 2), (SELECT 3, 4))`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE split_date USING pivot((SELECT 1), (SELECT 1, 2), (SELECT 3))`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+}
+
+func pretty(cols []string) string {
+	var buf strings.Builder
+	for i, s := range cols {
+		if i != 0 {
+			buf.WriteByte(' ')
+		}
+		for buf.Len()%8 != 0 {
+			buf.WriteByte(' ')
+		}
+		buf.WriteString(s)
+	}
+	return buf.String()
+}

ext/statement/stmt.go

@@ -0,0 +1,213 @@
+// Package statement defines table-valued functions using SQL.
+//
+// It can be used to create "parametrized views":
+// pre-packaged queries that can be parametrized at query execution time.
+//
+// https://github.com/0x09/sqlite-statement-vtab
+package statement
+
+import (
+	"encoding/json"
+	"errors"
+	"strconv"
+	"strings"
+	"unsafe"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+// Register registers the statement virtual table.
+func Register(db *sqlite3.Conn) {
+	sqlite3.CreateModule(db, "statement", declare, declare)
+}
+
+type table struct {
+	stmt  *sqlite3.Stmt
+	sql   string
+	inuse bool
+}
+
+func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (*table, error) {
+	if len(arg) != 1 {
+		return nil, errors.New("statement: wrong number of arguments")
+	}
+
+	sql := "SELECT * FROM\n" + arg[0]
+
+	stmt, _, err := db.Prepare(sql)
+	if err != nil {
+		return nil, err
+	}
+
+	var sep string
+	var str strings.Builder
+	str.WriteString("CREATE TABLE x(")
+	outputs := stmt.ColumnCount()
+	for i := 0; i < outputs; i++ {
+		name := sqlite3.QuoteIdentifier(stmt.ColumnName(i))
+		str.WriteString(sep)
+		str.WriteString(name)
+		str.WriteString(" ")
+		str.WriteString(stmt.ColumnDeclType(i))
+		sep = ","
+	}
+	inputs := stmt.BindCount()
+	for i := 1; i <= inputs; i++ {
+		str.WriteString(sep)
+		name := stmt.BindName(i)
+		if name == "" {
+			str.WriteString("[")
+			str.WriteString(strconv.Itoa(i))
+			str.WriteString("] HIDDEN")
+		} else {
+			str.WriteString(sqlite3.QuoteIdentifier(name[1:]))
+			str.WriteString(" HIDDEN")
+		}
+		sep = ","
+	}
+	str.WriteByte(')')
+
+	err = db.DeclareVTab(str.String())
+	if err != nil {
+		stmt.Close()
+		return nil, err
+	}
+
+	return &table{sql: sql, stmt: stmt}, nil
+}
+
+func (t *table) Close() error {
+	return t.stmt.Close()
+}
+
+func (t *table) BestIndex(idx *sqlite3.IndexInfo) error {
+	idx.EstimatedCost = 1000
+
+	var argvIndex = 1
+	var needIndex bool
+	var listIndex []int
+	outputs := t.stmt.ColumnCount()
+	for i, cst := range idx.Constraint {
+		// Skip if this is a constraint on one of our output columns.
+		if cst.Column < outputs {
+			continue
+		}
+
+		// A given query plan is only usable if all provided input columns
+		// are usable and have equal constraints only.
+		if !cst.Usable || cst.Op != sqlite3.INDEX_CONSTRAINT_EQ {
+			return sqlite3.CONSTRAINT
+		}
+
+		// The non-zero argvIdx values must be contiguous.
+		// If they're not, build a list and serialize it through IdxStr.
+		nextIndex := cst.Column - outputs + 1
+		idx.ConstraintUsage[i] = sqlite3.IndexConstraintUsage{
+			ArgvIndex: argvIndex,
+			Omit:      true,
+		}
+		if nextIndex != argvIndex {
+			needIndex = true
+		}
+		listIndex = append(listIndex, nextIndex)
+		argvIndex++
+	}
+
+	if needIndex {
+		buf, err := json.Marshal(listIndex)
+		if err != nil {
+			return err
+		}
+		idx.IdxStr = unsafe.String(&buf[0], len(buf))
+	}
+	return nil
+}
+
+func (t *table) Open() (sqlite3.VTabCursor, error) {
+	stmt := t.stmt
+	if !t.inuse {
+		t.inuse = true
+	} else {
+		var err error
+		stmt, _, err = t.stmt.Conn().Prepare(t.sql)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return &cursor{table: t, stmt: stmt}, nil
+}
+
+func (t *table) Rename(new string) error {
+	return nil
+}
+
+type cursor struct {
+	table *table
+	stmt  *sqlite3.Stmt
+	arg   []sqlite3.Value
+	rowID int64
+}
+
+func (c *cursor) Close() error {
+	if c.stmt == c.table.stmt {
+		c.table.inuse = false
+		c.stmt.ClearBindings()
+		return c.stmt.Reset()
+	}
+	return c.stmt.Close()
+}
+
+func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
+	c.arg = arg
+	c.rowID = 0
+	c.stmt.ClearBindings()
+	if err := c.stmt.Reset(); err != nil {
+		return err
+	}
+
+	var list []int
+	if idxStr != "" {
+		buf := unsafe.Slice(unsafe.StringData(idxStr), len(idxStr))
+		err := json.Unmarshal(buf, &list)
+		if err != nil {
+			return err
+		}
+	}
+
+	for i, arg := range arg {
+		param := i + 1
+		if list != nil {
+			param = list[i]
+		}
+		err := c.stmt.BindValue(param, arg)
+		if err != nil {
+			return err
+		}
+	}
+	return c.Next()
+}
+
+func (c *cursor) Next() error {
+	if c.stmt.Step() {
+		c.rowID++
+	}
+	return c.stmt.Err()
+}
+
+func (c *cursor) EOF() bool {
+	return !c.stmt.Busy()
+}
+
+func (c *cursor) RowID() (int64, error) {
+	return c.rowID, nil
+}
+
+func (c *cursor) Column(ctx *sqlite3.Context, col int) error {
+	switch outputs := c.stmt.ColumnCount(); {
+	case col < outputs:
+		ctx.ResultValue(c.stmt.ColumnValue(col))
+	case col-outputs < len(c.arg):
+		ctx.ResultValue(c.arg[col-outputs])
+	}
+	return nil
+}

ext/statement/stmt_test.go

@@ -0,0 +1,146 @@
+package statement_test
+
+import (
+	"fmt"
+	"log"
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+	_ "github.com/ncruces/go-sqlite3/embed"
+	"github.com/ncruces/go-sqlite3/ext/statement"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+)
+
+func Example() {
+	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
+				strftime('%Y', :date) AS year,
+				strftime('%m', :date) AS month,
+				strftime('%d', :date) AS day
+		))`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT * FROM split_date('2022-02-22')`)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer stmt.Close()
+
+	if stmt.Step() {
+		fmt.Printf("Twosday was %d-%d-%d", stmt.ColumnInt(0), stmt.ColumnInt(1), stmt.ColumnInt(2))
+	}
+	if err := stmt.Reset(); err != nil {
+		log.Fatal(err)
+	}
+
+	// Output:
+	// Twosday was 2022-2-22
+}
+
+func TestRegister(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	statement.Register(db)
+
+	err = db.Exec(`
+		CREATE VIRTUAL TABLE arguments USING statement((SELECT ? AS a, ? AS b, ? AS c))
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`
+		SELECT * from arguments WHERE [2] = 'y' AND [3] = 'z'
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`
+		CREATE VIRTUAL TABLE hypot USING statement((SELECT sqrt(:x * :x + :y * :y) AS hypotenuse))
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`
+		SELECT x, y, * FROM hypot WHERE x = 3 AND y = 4
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer stmt.Close()
+
+	if stmt.Step() {
+		x := stmt.ColumnInt(0)
+		y := stmt.ColumnInt(1)
+		hypot := stmt.ColumnInt(2)
+		if x != 3 || y != 4 || hypot != 5 {
+			t.Errorf("hypot(%d, %d) = %d", x, y, hypot)
+		}
+	}
+}
+
+func TestRegister_errors(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	statement.Register(db)
+
+	err = db.Exec(`CREATE VIRTUAL TABLE split_date USING statement()`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE split_date USING statement(SELECT 1, SELECT 2)`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE split_date USING statement((SELECT 1, SELECT 2))`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE split_date USING statement((SELECT 1; SELECT 2))`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE split_date USING statement((CREATE TABLE x(val)))`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+}

ext/stats/TODO.md

@@ -0,0 +1,56 @@
+# ANSI SQL Aggregate Functions
+
+https://www.oreilly.com/library/view/sql-in-a/9780596155322/ch04s02.html
+
+## Built in aggregates
+
+- [x] `COUNT(*)`
+- [x] `COUNT(expression)`
+- [x] `SUM(expression)`
+- [x] `AVG(expression)`
+- [x] `MIN(expression)`
+- [x] `MAX(expression)`
+
+https://sqlite.org/lang_aggfunc.html
+
+## Statistical aggregates
+
+- [x] `STDDEV_POP(expression)`
+- [x] `STDDEV_SAMP(expression)`
+- [x] `VAR_POP(expression)`
+- [x] `VAR_SAMP(expression)`
+- [x] `COVAR_POP(dependent, independent)`
+- [x] `COVAR_SAMP(dependent, independent)`
+- [x] `CORR(dependent, independent)`
+
+## Linear regression aggregates
+
+- [X] `REGR_AVGX(dependent, independent)`
+- [X] `REGR_AVGY(dependent, independent)`
+- [X] `REGR_SXX(dependent, independent)`
+- [X] `REGR_SYY(dependent, independent)`
+- [X] `REGR_SXY(dependent, independent)`
+- [X] `REGR_COUNT(dependent, independent)`
+- [X] `REGR_SLOPE(dependent, independent)`
+- [X] `REGR_INTERCEPT(dependent, independent)`
+- [X] `REGR_R2(dependent, independent)`
+
+## Set aggregates
+
+- [X] `CUME_DIST() OVER window`
+- [X] `RANK() OVER window`
+- [X] `DENSE_RANK() OVER window`
+- [X] `PERCENT_RANK() OVER window`
+
+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

@@ -1,6 +1,6 @@
 // Package stats provides aggregate functions for statistics.
 //
-// Functions:
+// Provided functions:
 //   - stddev_pop: population standard deviation
 //   - stddev_samp: sample standard deviation
 //   - var_pop: population variance
@@ -8,9 +8,39 @@
 //   - covar_pop: population covariance
 //   - covar_samp: sample covariance
 //   - corr: correlation coefficient
+//   - regr_r2: correlation coefficient squared
+//   - regr_avgx: average of the independent variable
+//   - regr_avgy: average of the dependent variable
+//   - regr_sxx: sum of the squares of the independent variable
+//   - regr_syy: sum of the squares of the dependent variable
+//   - regr_sxy: sum of the products of each pair of variables
+//   - regr_count: count non-null pairs of variables
+//   - 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
+//   - sum: sum values
+//   - avg: average value
+//   - 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
 
@@ -26,6 +56,21 @@ func Register(db *sqlite3.Conn) {
 	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 (
@@ -34,6 +79,16 @@ const (
 	stddev_pop
 	stddev_samp
 	corr
+	regr_r2
+	regr_sxx
+	regr_syy
+	regr_sxy
+	regr_avgx
+	regr_avgy
+	regr_slope
+	regr_intercept
+	regr_count
+	regr_json
 )
 
 func newVariance(kind int) func() sqlite3.AggregateFunction {
@@ -61,13 +116,13 @@ func (fn *variance) Value(ctx sqlite3.Context) {
 }
 
 func (fn *variance) Step(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	if a := arg[0]; a.Type() != sqlite3.NULL {
+	if a := arg[0]; a.NumericType() != sqlite3.NULL {
 		fn.enqueue(a.Float())
 	}
 }
 
 func (fn *variance) Inverse(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	if a := arg[0]; a.Type() != sqlite3.NULL {
+	if a := arg[0]; a.NumericType() != sqlite3.NULL {
 		fn.dequeue(a.Float())
 	}
 }
@@ -90,20 +145,42 @@ func (fn *covariance) Value(ctx sqlite3.Context) {
 		r = fn.covar_samp()
 	case corr:
 		r = fn.correlation()
+	case regr_r2:
+		r = fn.regr_r2()
+	case regr_sxx:
+		r = fn.regr_sxx()
+	case regr_syy:
+		r = fn.regr_syy()
+	case regr_sxy:
+		r = fn.regr_sxy()
+	case regr_avgx:
+		r = fn.regr_avgx()
+	case regr_avgy:
+		r = fn.regr_avgy()
+	case regr_slope:
+		r = fn.regr_slope()
+	case regr_intercept:
+		r = fn.regr_intercept()
+	case regr_count:
+		ctx.ResultInt64(fn.regr_count())
+		return
+	case regr_json:
+		ctx.ResultText(fn.regr_json())
+		return
 	}
 	ctx.ResultFloat(r)
 }
 
 func (fn *covariance) Step(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	a, b := arg[0], arg[1]
-	if a.Type() != sqlite3.NULL && b.Type() != sqlite3.NULL {
+	if a.NumericType() != sqlite3.NULL && b.NumericType() != sqlite3.NULL {
 		fn.enqueue(a.Float(), b.Float())
 	}
 }
 
 func (fn *covariance) Inverse(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	a, b := arg[0], arg[1]
-	if a.Type() != sqlite3.NULL && b.Type() != sqlite3.NULL {
+	if a.NumericType() != sqlite3.NULL && b.NumericType() != sqlite3.NULL {
 		fn.dequeue(a.Float(), b.Float())
 	}
 }

ext/stats/stats_test.go

@@ -1,4 +1,4 @@
-package stats
+package stats_test
 
 import (
 	"math"
@@ -6,6 +6,8 @@ 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"
 )
 
 func TestRegister_variance(t *testing.T) {
@@ -17,9 +19,9 @@ func TestRegister_variance(t *testing.T) {
 	}
 	defer db.Close()
 
-	Register(db)
+	stats.Register(db)
 
-	err = db.Exec(`CREATE TABLE IF NOT EXISTS data (x)`)
+	err = db.Exec(`CREATE TABLE data (x)`)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -38,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)
@@ -60,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) {
@@ -89,25 +88,28 @@ func TestRegister_covariance(t *testing.T) {
 	}
 	defer db.Close()
 
-	Register(db)
+	stats.Register(db)
 
-	err = db.Exec(`CREATE TABLE IF NOT EXISTS data (x, y)`)
+	err = db.Exec(`CREATE TABLE data (y, x)`)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	err = db.Exec(`INSERT INTO data (x, y) VALUES (3, 70), (5, 80), (2, 60), (7, 90), (4, 75)`)
+	err = db.Exec(`INSERT INTO data (y, x) VALUES (3, 70), (5, 80), (2, 60), (7, 90), (4, 75)`)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	stmt, _, err := db.Prepare(`SELECT
-		corr(x, y), covar_samp(x, y), covar_pop(x, y) FROM data`)
+		corr(y, x), covar_samp(y, x), covar_pop(y, x),
+		regr_avgy(y, x), regr_avgx(y, x),
+		regr_syy(y, x), regr_sxx(y, x), regr_sxy(y, x),
+		regr_slope(y, x), regr_intercept(y, x), regr_r2(y, x),
+		regr_count(y, x), regr_json(y, x)
+		FROM data`)
 	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)
@@ -118,23 +120,125 @@ func TestRegister_covariance(t *testing.T) {
 		if got := stmt.ColumnFloat(2); got != 17 {
 			t.Errorf("got %v, want 17", got)
 		}
+		if got := stmt.ColumnFloat(3); got != 4.2 {
+			t.Errorf("got %v, want 4.2", got)
+		}
+		if got := stmt.ColumnFloat(4); got != 75 {
+			t.Errorf("got %v, want 75", got)
+		}
+		if got := stmt.ColumnFloat(5); got != 14.8 {
+			t.Errorf("got %v, want 14.8", got)
+		}
+		if got := stmt.ColumnFloat(6); got != 500 {
+			t.Errorf("got %v, want 500", got)
+		}
+		if got := stmt.ColumnFloat(7); got != 85 {
+			t.Errorf("got %v, want 85", got)
+		}
+		if got := stmt.ColumnFloat(8); got != 0.17 {
+			t.Errorf("got %v, want 0.17", got)
+		}
+		if got := stmt.ColumnFloat(9); got != -8.55 {
+			t.Errorf("got %v, want -8.55", got)
+		}
+		if got := stmt.ColumnFloat(10); got != 0.9763513513513513 {
+			t.Errorf("got %v, want 0.9763513513513513", got)
+		}
+		if got := stmt.ColumnInt(11); got != 5 {
+			t.Errorf("got %v, want 5", got)
+		}
+		var a map[string]float64
+		if err := stmt.ColumnJSON(12, &a); err != nil {
+			t.Error(err)
+		} else if got := a["count"]; got != 5 {
+			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(x, y) 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()
+		if got := stmt.ColumnType(0); (got == sqlite3.FLOAT) != (want[i] != 0) {
+			t.Errorf("got %v, want %v", got, want[i])
+		}
+	}
+	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])
-			}
+func Benchmark_average(b *testing.B) {
+	sqlite3.Initialize()
+	b.ResetTimer()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer db.Close()
+
+	stmt, _, err := db.Prepare(`SELECT avg(value) FROM generate_series(0, ?)`)
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer stmt.Close()
+
+	err = stmt.BindInt(1, b.N)
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	if stmt.Step() {
+		want := float64(b.N) / 2
+		if got := stmt.ColumnFloat(0); got != want {
+			b.Errorf("got %v, want %v", got, want)
 		}
 	}
+
+	err = stmt.Err()
+	if err != nil {
+		b.Error(err)
+	}
+}
+
+func Benchmark_variance(b *testing.B) {
+	sqlite3.Initialize()
+	b.ResetTimer()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer db.Close()
+
+	stats.Register(db)
+
+	stmt, _, err := db.Prepare(`SELECT var_pop(value) FROM generate_series(0, ?)`)
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer stmt.Close()
+
+	err = stmt.BindInt(1, b.N)
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	if stmt.Step() && b.N > 100 {
+		want := float64(b.N*b.N) / 12
+		if got := stmt.ColumnFloat(0); want > (got-want)*float64(b.N) {
+			b.Errorf("got %v, want %v", got, want)
+		}
+	}
+
+	err = stmt.Err()
+	if err != nil {
+		b.Error(err)
+	}
 }

ext/stats/welford.go

@@ -1,14 +1,21 @@
 package stats
 
-import "math"
+import (
+	"math"
+	"strconv"
+	"strings"
+)
 
 // Welford's algorithm with Kahan summation:
 // https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm
 // https://en.wikipedia.org/wiki/Kahan_summation_algorithm
 
+// See also:
+// https://duckdb.org/docs/sql/aggregates.html#statistical-aggregates
+
 type welford struct {
 	m1, m2 kahan
-	n      uint64
+	n      int64
 }
 
 func (w welford) average() float64 {
@@ -48,10 +55,10 @@ func (w *welford) dequeue(x float64) {
 }
 
 type welford2 struct {
-	m1x, m2x kahan
 	m1y, m2y kahan
+	m1x, m2x kahan
 	cov      kahan
-	n        uint64
+	n        int64
 }
 
 func (w welford2) covar_pop() float64 {
@@ -63,33 +70,98 @@ func (w welford2) covar_samp() float64 {
 }
 
 func (w welford2) correlation() float64 {
-	return w.cov.hi / math.Sqrt(w.m2x.hi*w.m2y.hi)
+	return w.cov.hi / math.Sqrt(w.m2y.hi*w.m2x.hi)
 }
 
-func (w *welford2) enqueue(x, y float64) {
+func (w welford2) regr_avgy() float64 {
+	return w.m1y.hi
+}
+
+func (w welford2) regr_avgx() float64 {
+	return w.m1x.hi
+}
+
+func (w welford2) regr_syy() float64 {
+	return w.m2y.hi
+}
+
+func (w welford2) regr_sxx() float64 {
+	return w.m2x.hi
+}
+
+func (w welford2) regr_sxy() float64 {
+	return w.cov.hi
+}
+
+func (w welford2) regr_count() int64 {
+	return w.n
+}
+
+func (w welford2) regr_slope() float64 {
+	return w.cov.hi / w.m2x.hi
+}
+
+func (w welford2) regr_intercept() float64 {
+	slope := -w.regr_slope()
+	hi := math.FMA(slope, w.m1x.hi, w.m1y.hi)
+	lo := math.FMA(slope, w.m1x.lo, w.m1y.lo)
+	return hi + lo
+}
+
+func (w welford2) regr_r2() float64 {
+	return w.cov.hi * w.cov.hi / (w.m2y.hi * w.m2x.hi)
+}
+
+func (w welford2) regr_json() string {
+	var json strings.Builder
+	var num [32]byte
+	json.Grow(128)
+	json.WriteString(`{"count":`)
+	json.Write(strconv.AppendInt(num[:0], w.regr_count(), 10))
+	json.WriteString(`,"avgy":`)
+	json.Write(strconv.AppendFloat(num[:0], w.regr_avgy(), 'g', -1, 64))
+	json.WriteString(`,"avgx":`)
+	json.Write(strconv.AppendFloat(num[:0], w.regr_avgx(), 'g', -1, 64))
+	json.WriteString(`,"syy":`)
+	json.Write(strconv.AppendFloat(num[:0], w.regr_syy(), 'g', -1, 64))
+	json.WriteString(`,"sxx":`)
+	json.Write(strconv.AppendFloat(num[:0], w.regr_sxx(), 'g', -1, 64))
+	json.WriteString(`,"sxy":`)
+	json.Write(strconv.AppendFloat(num[:0], w.regr_sxy(), 'g', -1, 64))
+	json.WriteString(`,"slope":`)
+	json.Write(strconv.AppendFloat(num[:0], w.regr_slope(), 'g', -1, 64))
+	json.WriteString(`,"intercept":`)
+	json.Write(strconv.AppendFloat(num[:0], w.regr_intercept(), 'g', -1, 64))
+	json.WriteString(`,"r2":`)
+	json.Write(strconv.AppendFloat(num[:0], w.regr_r2(), 'g', -1, 64))
+	json.WriteByte('}')
+	return json.String()
+}
+
+func (w *welford2) enqueue(y, x float64) {
 	w.n++
-	d1x := x - w.m1x.hi - w.m1x.lo
 	d1y := y - w.m1y.hi - w.m1y.lo
-	w.m1x.add(d1x / float64(w.n))
+	d1x := x - w.m1x.hi - w.m1x.lo
 	w.m1y.add(d1y / float64(w.n))
-	d2x := x - w.m1x.hi - w.m1x.lo
+	w.m1x.add(d1x / float64(w.n))
 	d2y := y - w.m1y.hi - w.m1y.lo
-	w.m2x.add(d1x * d2x)
+	d2x := x - w.m1x.hi - w.m1x.lo
 	w.m2y.add(d1y * d2y)
-	w.cov.add(d1x * d2y)
+	w.m2x.add(d1x * d2x)
+	w.cov.add(d1y * d2x)
 }
 
-func (w *welford2) dequeue(x, y float64) {
+func (w *welford2) dequeue(y, x float64) {
 	w.n--
-	d1x := x - w.m1x.hi - w.m1x.lo
 	d1y := y - w.m1y.hi - w.m1y.lo
-	w.m1x.sub(d1x / float64(w.n))
+	d1x := x - w.m1x.hi - w.m1x.lo
 	w.m1y.sub(d1y / float64(w.n))
-	d2x := x - w.m1x.hi - w.m1x.lo
+	w.m1x.sub(d1x / float64(w.n))
 	d2y := y - w.m1y.hi - w.m1y.lo
-	w.m2x.sub(d1x * d2x)
+	d2x := x - w.m1x.hi - w.m1x.lo
 	w.m2y.sub(d1y * d2y)
-	w.cov.sub(d1x * d2y)
+	w.m2x.sub(d1x * d2x)
+	w.cov.sub(d1y * d2x)
 }
 
 type kahan struct{ hi, lo float64 }

ext/stats/welford_test.go

@@ -6,6 +6,8 @@ import (
 )
 
 func Test_welford(t *testing.T) {
+	t.Parallel()
+
 	var s1, s2 welford
 
 	s1.enqueue(4)
@@ -38,6 +40,8 @@ func Test_welford(t *testing.T) {
 }
 
 func Test_covar(t *testing.T) {
+	t.Parallel()
+
 	var c1, c2 welford2
 
 	c1.enqueue(3, 70)
@@ -64,6 +68,8 @@ func Test_covar(t *testing.T) {
 }
 
 func Test_correlation(t *testing.T) {
+	t.Parallel()
+
 	var c welford2
 	c.enqueue(1, 3)
 	c.enqueue(2, 2)

ext/unicode/unicode.go

@@ -8,7 +8,7 @@
 // The implementation is not 100% compatible with the [ICU extension]:
 //   - upper() and lower() use [strings.ToUpper], [strings.ToLower] and [cases];
 //   - the LIKE operator follows [strings.EqualFold] rules;
-//   - the REGEXP operator uses Go [regex/syntax];
+//   - the REGEXP operator uses Go [regexp/syntax];
 //   - collation sequences use [collate].
 //
 // Expect subtle differences (e.g.) in the handling of Turkish case folding.
@@ -113,14 +113,14 @@ func regex(ctx sqlite3.Context, arg ...sqlite3.Value) {
 		re = r
 		ctx.SetAuxData(0, re)
 	}
-	ctx.ResultBool(re.Match(arg[1].RawBlob()))
+	ctx.ResultBool(re.Match(arg[1].RawText()))
 }
 
 func like(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	escape := rune(-1)
 	if len(arg) == 3 {
 		var size int
-		b := arg[2].RawBlob()
+		b := arg[2].RawText()
 		escape, size = utf8.DecodeRune(b)
 		if size != len(b) {
 			ctx.ResultError(util.ErrorString("ESCAPE expression must be a single character"))
@@ -141,7 +141,7 @@ func like(ctx sqlite3.Context, arg ...sqlite3.Value) {
 		}
 		ctx.SetAuxData(0, re)
 	}
-	ctx.ResultBool(re.Match(arg[1].RawBlob()))
+	ctx.ResultBool(re.Match(arg[1].RawText()))
 }
 
 func like2regex(pattern string, escape rune) string {

ext/unicode/unicode_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func TestRegister(t *testing.T) {
@@ -81,7 +82,7 @@ func TestRegister_collation(t *testing.T) {
 
 	Register(db)
 
-	err = db.Exec(`CREATE TABLE IF NOT EXISTS words (word VARCHAR(10))`)
+	err = db.Exec(`CREATE TABLE words (word VARCHAR(10))`)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -189,6 +190,8 @@ func TestRegister_error(t *testing.T) {
 }
 
 func Test_like2regex(t *testing.T) {
+	t.Parallel()
+
 	const prefix = `(?is)\A`
 	const sufix = `\z`
 	tests := []struct {

ext/zorder/zorder.go

@@ -0,0 +1,58 @@
+// Package zorder provides functions for z-order transformations.
+//
+// https://sqlite.org/src/doc/tip/ext/misc/zorder.c
+package zorder
+
+import (
+	"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) {
+	flags := sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
+	db.CreateFunction("zorder", -1, flags, zorder)
+	db.CreateFunction("unzorder", 3, flags, unzorder)
+}
+
+func zorder(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	var x [63]int64
+	for i := range arg {
+		x[i] = arg[i].Int64()
+	}
+	if len(arg) > len(x) {
+		ctx.ResultError(util.ErrorString("zorder: too many parameters"))
+		return
+	}
+
+	var z int64
+	if len(arg) > 0 {
+		for i := 0; i < 63; i++ {
+			j := i % len(arg)
+			z |= (x[j] & 1) << i
+			x[j] >>= 1
+		}
+	}
+
+	for i := range arg {
+		if x[i] != 0 {
+			ctx.ResultError(util.ErrorString("zorder: parameter too large"))
+			return
+		}
+	}
+	ctx.ResultInt64(z)
+}
+
+func unzorder(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	z := arg[0].Int64()
+	n := arg[1].Int64()
+	i := arg[2].Int64()
+
+	var k int
+	var x int64
+	for j := i; j < 63; j += n {
+		x |= ((z >> j) & 1) << k
+		k++
+	}
+	ctx.ResultInt64(x)
+}

ext/zorder/zorder_test.go

@@ -0,0 +1,107 @@
+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"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+)
+
+func TestRegister_zorder(t *testing.T) {
+	t.Parallel()
+
+	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
+		zorder.Register(c)
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	var got int64
+	err = db.QueryRow(`SELECT zorder(2, 3)`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != 14 {
+		t.Errorf("got %d, want 14", got)
+	}
+
+	err = db.QueryRow(`SELECT zorder(4, 5)`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != 50 {
+		t.Errorf("got %d, want 14", got)
+	}
+
+	var check bool
+	err = db.QueryRow(`SELECT zorder(3, 4) BETWEEN zorder(2, 3) AND zorder(4, 5)`).Scan(&check)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !check {
+		t.Error("want true")
+	}
+
+	err = db.QueryRow(`SELECT zorder(2, 2) NOT BETWEEN zorder(2, 3) AND zorder(4, 5)`).Scan(&check)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !check {
+		t.Error("want true")
+	}
+}
+
+func TestRegister_unzorder(t *testing.T) {
+	t.Parallel()
+
+	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
+		zorder.Register(c)
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	var got int64
+	err = db.QueryRow(`SELECT unzorder(zorder(3, 4), 2, 0)`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != 3 {
+		t.Errorf("got %d, want 3", got)
+	}
+
+	err = db.QueryRow(`SELECT unzorder(zorder(3, 4), 2, 1)`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != 4 {
+		t.Errorf("got %d, want 4", got)
+	}
+}
+
+func TestRegister_error(t *testing.T) {
+	t.Parallel()
+
+	db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error {
+		zorder.Register(c)
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	var got int64
+	err = db.QueryRow(`SELECT zorder(1, 2, 3, 100000)`).Scan(&got)
+	if err == nil {
+		t.Error("want error")
+	}
+}

func.go

@@ -2,29 +2,47 @@ package sqlite3
 
 import (
 	"context"
+	"sync"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
 	"github.com/tetratelabs/wazero/api"
 )
 
-// AnyCollationNeeded registers a fake collating function
-// for any unknown collating sequence.
+// CollationNeeded registers a callback to be invoked
+// whenever an unknown collation sequence is required.
+//
+// https://sqlite.org/c3ref/collation_needed.html
+func (c *Conn) CollationNeeded(cb func(db *Conn, name string)) error {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	r := c.call("sqlite3_collation_needed_go", uint64(c.handle), enable)
+	if err := c.error(r); err != nil {
+		return err
+	}
+	c.collation = cb
+	return nil
+}
+
+// AnyCollationNeeded uses [Conn.CollationNeeded] to register
+// a fake collating function for any unknown collating sequence.
 // The fake collating function works like BINARY.
 //
 // This can be used to load schemas that contain
 // one or more unknown collating sequences.
 func (c *Conn) AnyCollationNeeded() {
-	c.call(c.api.anyCollation, uint64(c.handle), 0, 0)
+	c.call("sqlite3_anycollseq_init", uint64(c.handle), 0, 0)
 }
 
 // CreateCollation defines a new collating sequence.
 //
 // https://sqlite.org/c3ref/create_collation.html
 func (c *Conn) CreateCollation(name string, fn func(a, b []byte) int) error {
-	defer c.arena.reset()
+	defer c.arena.mark()()
 	namePtr := c.arena.string(name)
 	funcPtr := util.AddHandle(c.ctx, fn)
-	r := c.call(c.api.createCollation,
+	r := c.call("sqlite3_create_collation_go",
 		uint64(c.handle), uint64(namePtr), uint64(funcPtr))
 	return c.error(r)
 }
@@ -32,28 +50,32 @@ func (c *Conn) CreateCollation(name string, fn func(a, b []byte) int) error {
 // CreateFunction defines a new scalar SQL function.
 //
 // https://sqlite.org/c3ref/create_function.html
-func (c *Conn) CreateFunction(name string, nArg int, flag FunctionFlag, fn func(ctx Context, arg ...Value)) error {
-	defer c.arena.reset()
+func (c *Conn) CreateFunction(name string, nArg int, flag FunctionFlag, fn ScalarFunction) error {
+	defer c.arena.mark()()
 	namePtr := c.arena.string(name)
 	funcPtr := util.AddHandle(c.ctx, fn)
-	r := c.call(c.api.createFunction,
+	r := c.call("sqlite3_create_function_go",
 		uint64(c.handle), uint64(namePtr), uint64(nArg),
 		uint64(flag), uint64(funcPtr))
 	return c.error(r)
 }
 
+// ScalarFunction is the type of a scalar SQL function.
+// Implementations must not retain arg.
+type ScalarFunction func(ctx Context, arg ...Value)
+
 // CreateWindowFunction defines a new aggregate or aggregate window SQL function.
 // If fn returns a [WindowFunction], then an aggregate window function is created.
 // If fn returns an [io.Closer], it will be called to free resources.
 //
 // https://sqlite.org/c3ref/create_function.html
 func (c *Conn) CreateWindowFunction(name string, nArg int, flag FunctionFlag, fn func() AggregateFunction) error {
-	defer c.arena.reset()
-	call := c.api.createAggregate
+	defer c.arena.mark()()
+	call := "sqlite3_create_aggregate_function_go"
 	namePtr := c.arena.string(name)
 	funcPtr := util.AddHandle(c.ctx, fn)
 	if _, ok := fn().(WindowFunction); ok {
-		call = c.api.createWindow
+		call = "sqlite3_create_window_function_go"
 	}
 	r := c.call(call,
 		uint64(c.handle), uint64(namePtr), uint64(nArg),
@@ -66,7 +88,8 @@ func (c *Conn) CreateWindowFunction(name string, nArg int, flag FunctionFlag, fn
 // https://sqlite.org/appfunc.html
 type AggregateFunction interface {
 	// Step is invoked to add a row to the current window.
-	// The function arguments, if any, corresponding to the row being added are passed to Step.
+	// The function arguments, if any, corresponding to the row being added, are passed to Step.
+	// Implementations must not retain arg.
 	Step(ctx Context, arg ...Value)
 
 	// Value is invoked to return the current (or final) value of the aggregate.
@@ -81,92 +104,111 @@ type WindowFunction interface {
 
 	// Inverse is invoked to remove the oldest presently aggregated result of Step from the current window.
 	// The function arguments, if any, are those passed to Step for the row being removed.
+	// Implementations must not retain arg.
 	Inverse(ctx Context, arg ...Value)
 }
 
+// OverloadFunction overloads a function for a virtual table.
+//
+// https://sqlite.org/c3ref/overload_function.html
+func (c *Conn) OverloadFunction(name string, nArg int) error {
+	defer c.arena.mark()()
+	namePtr := c.arena.string(name)
+	r := c.call("sqlite3_overload_function",
+		uint64(c.handle), uint64(namePtr), uint64(nArg))
+	return c.error(r)
+}
+
 func destroyCallback(ctx context.Context, mod api.Module, pApp uint32) {
 	util.DelHandle(ctx, pApp)
 }
 
+func collationCallback(ctx context.Context, mod api.Module, pArg, pDB, eTextRep, zName uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.collation != nil {
+		name := util.ReadString(mod, zName, _MAX_NAME)
+		c.collation(c, name)
+	}
+}
+
 func compareCallback(ctx context.Context, mod api.Module, pApp, nKey1, pKey1, nKey2, pKey2 uint32) uint32 {
 	fn := util.GetHandle(ctx, pApp).(func(a, b []byte) int)
 	return uint32(fn(util.View(mod, pKey1, uint64(nKey1)), util.View(mod, pKey2, uint64(nKey2))))
 }
 
-func funcCallback(ctx context.Context, mod api.Module, pCtx, nArg, pArg uint32) {
+func funcCallback(ctx context.Context, mod api.Module, pCtx, pApp, nArg, pArg uint32) {
+	args := getFuncArgs()
+	defer putFuncArgs(args)
 	db := ctx.Value(connKey{}).(*Conn)
-	fn := userDataHandle(db, pCtx).(func(ctx Context, arg ...Value))
-	fn(Context{db, pCtx}, callbackArgs(db, nArg, pArg)...)
+	fn := util.GetHandle(db.ctx, pApp).(ScalarFunction)
+	callbackArgs(db, args[:nArg], pArg)
+	fn(Context{db, pCtx}, args[:nArg]...)
 }
 
-func stepCallback(ctx context.Context, mod api.Module, pCtx, nArg, pArg uint32) {
+func stepCallback(ctx context.Context, mod api.Module, pCtx, pAgg, pApp, nArg, pArg uint32) {
+	args := getFuncArgs()
+	defer putFuncArgs(args)
 	db := ctx.Value(connKey{}).(*Conn)
-	fn := aggregateCtxHandle(db, pCtx, nil)
-	fn.Step(Context{db, pCtx}, callbackArgs(db, nArg, pArg)...)
+	callbackArgs(db, args[:nArg], pArg)
+	fn, _ := callbackAggregate(db, pAgg, pApp)
+	fn.Step(Context{db, pCtx}, args[:nArg]...)
 }
 
-func finalCallback(ctx context.Context, mod api.Module, pCtx uint32) {
-	var handle uint32
+func finalCallback(ctx context.Context, mod api.Module, pCtx, pAgg, pApp uint32) {
 	db := ctx.Value(connKey{}).(*Conn)
-	fn := aggregateCtxHandle(db, pCtx, &handle)
+	fn, handle := callbackAggregate(db, pAgg, pApp)
 	fn.Value(Context{db, pCtx})
-	if err := util.DelHandle(ctx, handle); err != nil {
-		Context{db, pCtx}.ResultError(err)
-	}
+	util.DelHandle(ctx, handle)
 }
 
-func valueCallback(ctx context.Context, mod api.Module, pCtx uint32) {
+func valueCallback(ctx context.Context, mod api.Module, pCtx, pAgg uint32) {
 	db := ctx.Value(connKey{}).(*Conn)
-	fn := aggregateCtxHandle(db, pCtx, nil)
+	fn := util.GetHandle(db.ctx, pAgg).(AggregateFunction)
 	fn.Value(Context{db, pCtx})
 }
 
-func inverseCallback(ctx context.Context, mod api.Module, pCtx, nArg, pArg uint32) {
+func inverseCallback(ctx context.Context, mod api.Module, pCtx, pAgg, nArg, pArg uint32) {
+	args := getFuncArgs()
+	defer putFuncArgs(args)
 	db := ctx.Value(connKey{}).(*Conn)
-	fn := aggregateCtxHandle(db, pCtx, nil).(WindowFunction)
-	fn.Inverse(Context{db, pCtx}, callbackArgs(db, nArg, pArg)...)
+	callbackArgs(db, args[:nArg], pArg)
+	fn := util.GetHandle(db.ctx, pAgg).(WindowFunction)
+	fn.Inverse(Context{db, pCtx}, args[:nArg]...)
 }
 
-func userDataHandle(db *Conn, pCtx uint32) any {
-	pApp := uint32(db.call(db.api.userData, uint64(pCtx)))
-	return util.GetHandle(db.ctx, pApp)
+func callbackAggregate(db *Conn, pAgg, pApp uint32) (AggregateFunction, uint32) {
+	if pApp == 0 {
+		handle := util.ReadUint32(db.mod, pAgg)
+		return util.GetHandle(db.ctx, handle).(AggregateFunction), handle
+	}
+
+	// We need to create the aggregate.
+	fn := util.GetHandle(db.ctx, pApp).(func() AggregateFunction)()
+	handle := util.AddHandle(db.ctx, fn)
+	if pAgg != 0 {
+		util.WriteUint32(db.mod, pAgg, handle)
+	}
+	return fn, handle
 }
 
-func aggregateCtxHandle(db *Conn, pCtx uint32, close *uint32) AggregateFunction {
-	// On close, we're getting rid of the aggregate.
-	// Don't allocate space to store it.
-	var size uint64
-	if close == nil {
-		size = ptrlen
-	}
-	ptr := uint32(db.call(db.api.aggregateCtx, uint64(pCtx), size))
-
-	// If we already have an aggregate, return it.
-	if ptr != 0 {
-		if handle := util.ReadUint32(db.mod, ptr); handle != 0 {
-			fn := util.GetHandle(db.ctx, handle).(AggregateFunction)
-			if close != nil {
-				*close = handle
-			}
-			return fn
-		}
-	}
-
-	// Create a new aggregate, and store it if needed.
-	fn := userDataHandle(db, pCtx).(func() AggregateFunction)()
-	if ptr != 0 {
-		util.WriteUint32(db.mod, ptr, util.AddHandle(db.ctx, fn))
-	}
-	return fn
-}
-
-func callbackArgs(db *Conn, nArg, pArg uint32) []Value {
-	args := make([]Value, nArg)
-	for i := range args {
-		args[i] = Value{
-			sqlite: db.sqlite,
+func callbackArgs(db *Conn, arg []Value, pArg uint32) {
+	for i := range arg {
+		arg[i] = Value{
+			c:      db,
 			handle: util.ReadUint32(db.mod, pArg+ptrlen*uint32(i)),
 		}
 	}
-	return args
+}
+
+var funcArgsPool sync.Pool
+
+func putFuncArgs(p *[_MAX_FUNCTION_ARG]Value) {
+	funcArgsPool.Put(p)
+}
+
+func getFuncArgs() *[_MAX_FUNCTION_ARG]Value {
+	if p := funcArgsPool.Get(); p == nil {
+		return new([_MAX_FUNCTION_ARG]Value)
+	} else {
+		return p.(*[_MAX_FUNCTION_ARG]Value)
+	}
 }

func_test.go

@@ -6,11 +6,10 @@ import (
 	"log"
 	"regexp"
 
-	"golang.org/x/text/collate"
-	"golang.org/x/text/language"
-
 	"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() {
@@ -20,7 +19,7 @@ func ExampleConn_CreateCollation() {
 	}
 	defer db.Close()
 
-	err = db.Exec(`CREATE TABLE IF NOT EXISTS words (word VARCHAR(10))`)
+	err = db.Exec(`CREATE TABLE words (word VARCHAR(10))`)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -30,12 +29,17 @@ func ExampleConn_CreateCollation() {
 		log.Fatal(err)
 	}
 
-	err = db.CreateCollation("french", collate.New(language.French).Compare)
+	err = db.CollationNeeded(func(db *sqlite3.Conn, name string) {
+		err := unicode.RegisterCollation(db, name, name)
+		if err != nil {
+			log.Fatal(err)
+		}
+	})
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	stmt, _, err := db.Prepare(`SELECT word FROM words ORDER BY word COLLATE french`)
+	stmt, _, err := db.Prepare(`SELECT word FROM words ORDER BY word COLLATE fr_FR`)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -63,7 +67,7 @@ func ExampleConn_CreateFunction() {
 	}
 	defer db.Close()
 
-	err = db.Exec(`CREATE TABLE IF NOT EXISTS words (word VARCHAR(10))`)
+	err = db.Exec(`CREATE TABLE words (word VARCHAR(10))`)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -108,7 +112,7 @@ func ExampleContext_SetAuxData() {
 	}
 	defer db.Close()
 
-	err = db.Exec(`CREATE TABLE IF NOT EXISTS words (word VARCHAR(10))`)
+	err = db.Exec(`CREATE TABLE words (word VARCHAR(10))`)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -129,7 +133,7 @@ func ExampleContext_SetAuxData() {
 			ctx.SetAuxData(0, r)
 			re = r
 		}
-		ctx.ResultBool(re.Match(arg[1].RawBlob()))
+		ctx.ResultBool(re.Match(arg[1].RawText()))
 	})
 	if err != nil {
 		log.Fatal(err)

func_win_test.go

@@ -16,7 +16,7 @@ func ExampleConn_CreateWindowFunction() {
 	}
 	defer db.Close()
 
-	err = db.Exec(`CREATE TABLE IF NOT EXISTS words (word VARCHAR(10))`)
+	err = db.Exec(`CREATE TABLE words (word VARCHAR(10))`)
 	if err != nil {
 		log.Fatal(err)
 	}

go.mod

@@ -3,12 +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.5.0
-	golang.org/x/sync v0.5.0
-	golang.org/x/sys v0.14.0
-	golang.org/x/text v0.14.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.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,12 +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.5.0 h1:Yz3fZHivfDiZFUXnWMPUoiW7s8tC1sjdBtlJn08qYa0=
-github.com/tetratelabs/wazero v1.5.0/go.mod h1:0U0G41+ochRKoPKCJlh0jMg1CHkyfK8kDqiirMmKY8A=
-golang.org/x/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE=
-golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.14.0 h1:Vz7Qs629MkJkGyHxUlRHizWJRG2j8fbQKjELVSNhy7Q=
-golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
-golang.org/x/text v0.14.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/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.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

@@ -1,4 +1,7 @@
-golang.org/x/mod v0.8.0 h1:LUYupSeNrTNCGzR/hVBk2NHZO4hXcVaW1k4Qx7rjPx8=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/tools v0.6.0 h1:BOw41kyTf3PuCW1pVQf8+Cyg8pMlkYB1oo9iJ6D/lKM=
+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/ddlmod.go

@@ -13,6 +13,7 @@ import (
 
 var (
 	sqliteSeparator    = "`|\"|'|\t"
+	uniqueRegexp       = regexp.MustCompile(fmt.Sprintf(`^CONSTRAINT [%v]?[\w-]+[%v]? UNIQUE (.*)$`, sqliteSeparator, sqliteSeparator))
 	indexRegexp        = regexp.MustCompile(fmt.Sprintf(`(?is)CREATE(?: UNIQUE)? INDEX [%v]?[\w\d-]+[%v]?(?s:.*?)ON (.*)$`, sqliteSeparator, sqliteSeparator))
 	tableRegexp        = regexp.MustCompile(fmt.Sprintf(`(?is)(CREATE TABLE [%v]?[\w\d-]+[%v]?)(?:\s*\((.*)\))?`, sqliteSeparator, sqliteSeparator))
 	separatorRegexp    = regexp.MustCompile(fmt.Sprintf("[%v]", sqliteSeparator))
@@ -103,11 +104,24 @@ func parseDDL(strs ...string) (*ddl, error) {
 
 			for _, f := range result.fields {
 				fUpper := strings.ToUpper(f)
-				if strings.HasPrefix(fUpper, "CHECK") ||
-					strings.HasPrefix(fUpper, "CONSTRAINT") {
+				if strings.HasPrefix(fUpper, "CHECK") {
+					continue
+				}
+				if strings.HasPrefix(fUpper, "CONSTRAINT") {
+					matches := uniqueRegexp.FindStringSubmatch(f)
+					if len(matches) > 0 {
+						if columns := getAllColumns(matches[1]); len(columns) == 1 {
+							for idx, column := range result.columns {
+								if column.NameValue.String == columns[0] {
+									column.UniqueValue = sql.NullBool{Bool: true, Valid: true}
+									result.columns[idx] = column
+									break
+								}
+							}
+						}
+					}
 					continue
 				}
-
 				if strings.HasPrefix(fUpper, "PRIMARY KEY") {
 					for _, name := range getAllColumns(f) {
 						for idx, column := range result.columns {
@@ -159,14 +173,7 @@ func parseDDL(strs ...string) (*ddl, error) {
 				}
 			}
 		} else if matches := indexRegexp.FindStringSubmatch(str); len(matches) > 0 {
-			for _, column := range getAllColumns(matches[1]) {
-				for idx, c := range result.columns {
-					if c.NameValue.String == column {
-						c.UniqueValue = sql.NullBool{Bool: strings.ToUpper(strings.Fields(str)[1]) == "UNIQUE", Valid: true}
-						result.columns[idx] = c
-					}
-				}
-			}
+			// don't report Unique by UniqueIndex
 		} else {
 			return nil, errors.New("invalid DDL")
 		}
@@ -269,20 +276,6 @@ func (d *ddl) getColumns() []string {
 	return res
 }
 
-func (d *ddl) alterColumn(name, sql string) bool {
-	reg := regexp.MustCompile("^(`|'|\"| )" + regexp.QuoteMeta(name) + "(`|'|\"| ) .*?$")
-
-	for i := 0; i < len(d.fields); i++ {
-		if reg.MatchString(d.fields[i]) {
-			d.fields[i] = sql
-			return false
-		}
-	}
-
-	d.fields = append(d.fields, sql)
-	return true
-}
-
 func (d *ddl) removeColumn(name string) bool {
 	reg := regexp.MustCompile("^(`|'|\"| )" + regexp.QuoteMeta(name) + "(`|'|\"| ) .*?$")
 

gormlite/ddlmod_test.go

@@ -16,11 +16,12 @@ func TestParseDDL(t *testing.T) {
 		columns []migrator.ColumnType
 	}{
 		{"with_fk", []string{
-			"CREATE TABLE `notes` (`id` integer NOT NULL,`text` varchar(500) DEFAULT \"hello\",`age` integer DEFAULT 18,`user_id` integer,PRIMARY KEY (`id`),CONSTRAINT `fk_users_notes` FOREIGN KEY (`user_id`) REFERENCES `users`(`id`))",
+			"CREATE TABLE `notes` (" +
+				"`id` integer NOT NULL,`text` varchar(500) DEFAULT \"hello\",`age` integer DEFAULT 18,`user_id` integer,PRIMARY KEY (`id`),CONSTRAINT `fk_users_notes` FOREIGN KEY (`user_id`) REFERENCES `users`(`id`))",
 			"CREATE UNIQUE INDEX `idx_profiles_refer` ON `profiles`(`text`)",
 		}, 6, []migrator.ColumnType{
 			{NameValue: sql.NullString{String: "id", Valid: true}, DataTypeValue: sql.NullString{String: "integer", Valid: true}, ColumnTypeValue: sql.NullString{String: "integer", Valid: true}, PrimaryKeyValue: sql.NullBool{Bool: true, Valid: true}, NullableValue: sql.NullBool{Valid: true}, UniqueValue: sql.NullBool{Valid: true}, DefaultValueValue: sql.NullString{Valid: false}},
-			{NameValue: sql.NullString{String: "text", Valid: true}, DataTypeValue: sql.NullString{String: "varchar", Valid: true}, LengthValue: sql.NullInt64{Int64: 500, Valid: true}, ColumnTypeValue: sql.NullString{String: "varchar(500)", Valid: true}, DefaultValueValue: sql.NullString{String: "hello", Valid: true}, NullableValue: sql.NullBool{Bool: true, Valid: true}, UniqueValue: sql.NullBool{Bool: true, Valid: true}, PrimaryKeyValue: sql.NullBool{Valid: true}},
+			{NameValue: sql.NullString{String: "text", Valid: true}, DataTypeValue: sql.NullString{String: "varchar", Valid: true}, LengthValue: sql.NullInt64{Int64: 500, Valid: true}, ColumnTypeValue: sql.NullString{String: "varchar(500)", Valid: true}, DefaultValueValue: sql.NullString{String: "hello", Valid: true}, NullableValue: sql.NullBool{Bool: true, Valid: true}, UniqueValue: sql.NullBool{Bool: false, Valid: true}, PrimaryKeyValue: sql.NullBool{Valid: true}},
 			{NameValue: sql.NullString{String: "age", Valid: true}, DataTypeValue: sql.NullString{String: "integer", Valid: true}, ColumnTypeValue: sql.NullString{String: "integer", Valid: true}, DefaultValueValue: sql.NullString{String: "18", Valid: true}, NullableValue: sql.NullBool{Bool: true, Valid: true}, UniqueValue: sql.NullBool{Valid: true}, PrimaryKeyValue: sql.NullBool{Valid: true}},
 			{NameValue: sql.NullString{String: "user_id", Valid: true}, DataTypeValue: sql.NullString{String: "integer", Valid: true}, ColumnTypeValue: sql.NullString{String: "integer", Valid: true}, DefaultValueValue: sql.NullString{Valid: false}, NullableValue: sql.NullBool{Bool: true, Valid: true}, UniqueValue: sql.NullBool{Valid: true}, PrimaryKeyValue: sql.NullBool{Valid: true}},
 		},
@@ -56,28 +57,54 @@ func TestParseDDL(t *testing.T) {
 					ColumnTypeValue:   sql.NullString{String: "int", Valid: true},
 					NullableValue:     sql.NullBool{Bool: false, Valid: true},
 					DefaultValueValue: sql.NullString{Valid: false},
-					UniqueValue:       sql.NullBool{Bool: true, Valid: true},
+					UniqueValue:       sql.NullBool{Bool: false, Valid: true},
 					PrimaryKeyValue:   sql.NullBool{Valid: true},
 				},
 			},
-		},
-		{
+		}, {
 			"unique index",
 			[]string{
 				"CREATE TABLE `test-b` (`field` integer NOT NULL)",
 				"CREATE UNIQUE INDEX `idx_uq` ON `test-b`(`field`) WHERE field = 0",
 			},
 			1,
-			[]migrator.ColumnType{
-				{
-					NameValue:       sql.NullString{String: "field", Valid: true},
-					DataTypeValue:   sql.NullString{String: "integer", Valid: true},
-					ColumnTypeValue: sql.NullString{String: "integer", Valid: true},
-					PrimaryKeyValue: sql.NullBool{Bool: false, Valid: true},
-					UniqueValue:     sql.NullBool{Bool: true, Valid: true},
-					NullableValue:   sql.NullBool{Bool: false, Valid: true},
-				},
+			[]migrator.ColumnType{{
+				NameValue:       sql.NullString{String: "field", Valid: true},
+				DataTypeValue:   sql.NullString{String: "integer", Valid: true},
+				ColumnTypeValue: sql.NullString{String: "integer", Valid: true},
+				PrimaryKeyValue: sql.NullBool{Bool: false, Valid: true},
+				UniqueValue:     sql.NullBool{Bool: false, Valid: true},
+				NullableValue:   sql.NullBool{Bool: false, Valid: true},
+			}},
+		}, {
+			"normal index",
+			[]string{
+				"CREATE TABLE `test-c` (`field` integer NOT NULL)",
+				"CREATE INDEX `idx_uq` ON `test-c`(`field`)",
 			},
+			1,
+			[]migrator.ColumnType{{
+				NameValue:       sql.NullString{String: "field", Valid: true},
+				DataTypeValue:   sql.NullString{String: "integer", Valid: true},
+				ColumnTypeValue: sql.NullString{String: "integer", Valid: true},
+				PrimaryKeyValue: sql.NullBool{Bool: false, Valid: true},
+				UniqueValue:     sql.NullBool{Bool: false, Valid: true},
+				NullableValue:   sql.NullBool{Bool: false, Valid: true},
+			}},
+		}, {
+			"unique constraint",
+			[]string{
+				"CREATE TABLE `unique_struct` (`name` text,CONSTRAINT `uni_unique_struct_name` UNIQUE (`name`))",
+			},
+			2,
+			[]migrator.ColumnType{{
+				NameValue:       sql.NullString{String: "name", Valid: true},
+				DataTypeValue:   sql.NullString{String: "text", Valid: true},
+				ColumnTypeValue: sql.NullString{String: "text", Valid: true},
+				PrimaryKeyValue: sql.NullBool{Bool: false, Valid: true},
+				UniqueValue:     sql.NullBool{Bool: true, Valid: true},
+				NullableValue:   sql.NullBool{Bool: true, Valid: true},
+			}},
 		},
 		{
 			"non-unique index",

gormlite/download.sh

@@ -3,9 +3,11 @@ set -euo pipefail
 
 cd -P -- "$(dirname -- "$0")"
 
-curl -#OL "https://github.com/go-gorm/sqlite/raw/master/ddlmod.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/master/ddlmod_test.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/master/error_translator.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/master/migrator.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/master/sqlite.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/master/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,14 +3,14 @@ module github.com/ncruces/go-sqlite3/gormlite
 go 1.21
 
 require (
-	github.com/ncruces/go-sqlite3 v0.10.5
-	gorm.io/gorm v1.25.5
+	github.com/ncruces/go-sqlite3 v0.16.3
+	gorm.io/gorm v1.25.10
 )
 
 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.5.0 // indirect
-	golang.org/x/sys v0.14.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.10.5 h1:SPnFFYajDfhTuJNjeNwdOhwVCRSAqB1PdSHsGrdfYjw=
-github.com/ncruces/go-sqlite3 v0.10.5/go.mod h1:8aGu9/G8lLZbvO6TXA0FXTP2liIefFmbpeXuhG4nJLw=
+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.5.0 h1:Yz3fZHivfDiZFUXnWMPUoiW7s8tC1sjdBtlJn08qYa0=
-github.com/tetratelabs/wazero v1.5.0/go.mod h1:0U0G41+ochRKoPKCJlh0jMg1CHkyfK8kDqiirMmKY8A=
-golang.org/x/sys v0.14.0 h1:Vz7Qs629MkJkGyHxUlRHizWJRG2j8fbQKjELVSNhy7Q=
-golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-gorm.io/gorm v1.25.5 h1:zR9lOiiYf09VNh5Q1gphfyia1JpiClIWG9hQaxB/mls=
-gorm.io/gorm v1.25.5/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
+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/migrator.go

@@ -79,14 +79,28 @@ func (m _Migrator) AlterColumn(value interface{}, name string) error {
 	return m.RunWithoutForeignKey(func() error {
 		return m.recreateTable(value, nil, func(ddl *ddl, stmt *gorm.Statement) (*ddl, []interface{}, error) {
 			if field := stmt.Schema.LookUpField(name); field != nil {
-				if ddl.alterColumn(field.DBName, fmt.Sprintf("`%s` ?", field.DBName)) {
-					return nil, nil, fmt.Errorf("field `%s` not found in origin ddl, ddl= '%s'", name, ddl.compile())
+				var sqlArgs []interface{}
+				for i, f := range ddl.fields {
+					if matches := columnRegexp.FindStringSubmatch(f); len(matches) > 1 && matches[1] == field.DBName {
+						ddl.fields[i] = fmt.Sprintf("`%v` ?", field.DBName)
+						sqlArgs = []interface{}{m.FullDataTypeOf(field)}
+						// table created by old version might look like `CREATE TABLE ? (? varchar(10) UNIQUE)`.
+						// FullDataTypeOf doesn't contain UNIQUE, so we need to add unique constraint.
+						if strings.Contains(strings.ToUpper(matches[3]), " UNIQUE") {
+							uniName := m.DB.NamingStrategy.UniqueName(stmt.Table, field.DBName)
+							uni, _ := m.GuessConstraintInterfaceAndTable(stmt, uniName)
+							if uni != nil {
+								uniSQL, uniArgs := uni.Build()
+								ddl.addConstraint(uniName, uniSQL)
+								sqlArgs = append(sqlArgs, uniArgs...)
+							}
+						}
+						break
+					}
 				}
-
-				return ddl, []interface{}{m.FullDataTypeOf(field)}, nil
+				return ddl, sqlArgs, nil
 			}
-
-			return nil, nil, fmt.Errorf("failed to alter field with name `%s`", name)
+			return nil, nil, fmt.Errorf("failed to alter field with name %v", name)
 		})
 	})
 }
@@ -153,7 +167,7 @@ func (m _Migrator) DropColumn(value interface{}, name string) error {
 
 func (m _Migrator) CreateConstraint(value interface{}, name string) error {
 	return m.RunWithValue(value, func(stmt *gorm.Statement) error {
-		constraint, chk, table := m.GuessConstraintAndTable(stmt, name)
+		constraint, table := m.GuessConstraintInterfaceAndTable(stmt, name)
 
 		return m.recreateTable(value, &table,
 			func(ddl *ddl, stmt *gorm.Statement) (*ddl, []interface{}, error) {
@@ -164,12 +178,8 @@ func (m _Migrator) CreateConstraint(value interface{}, name string) error {
 				)
 
 				if constraint != nil {
-					constraintName = constraint.Name
-					constraintSql, constraintValues = buildConstraint(constraint)
-				} else if chk != nil {
-					constraintName = chk.Name
-					constraintSql = "CONSTRAINT ? CHECK (?)"
-					constraintValues = []interface{}{clause.Column{Name: chk.Name}, clause.Expr{SQL: chk.Constraint}}
+					constraintName = constraint.GetName()
+					constraintSql, constraintValues = constraint.Build()
 				} else {
 					return nil, nil, nil
 				}
@@ -182,11 +192,9 @@ func (m _Migrator) CreateConstraint(value interface{}, name string) error {
 
 func (m _Migrator) DropConstraint(value interface{}, name string) error {
 	return m.RunWithValue(value, func(stmt *gorm.Statement) error {
-		constraint, chk, table := m.GuessConstraintAndTable(stmt, name)
+		constraint, table := m.GuessConstraintInterfaceAndTable(stmt, name)
 		if constraint != nil {
-			name = constraint.Name
-		} else if chk != nil {
-			name = chk.Name
+			name = constraint.GetName()
 		}
 
 		return m.recreateTable(value, &table,
@@ -200,11 +208,9 @@ func (m _Migrator) DropConstraint(value interface{}, name string) error {
 func (m _Migrator) HasConstraint(value interface{}, name string) bool {
 	var count int64
 	m.RunWithValue(value, func(stmt *gorm.Statement) error {
-		constraint, chk, table := m.GuessConstraintAndTable(stmt, name)
+		constraint, table := m.GuessConstraintInterfaceAndTable(stmt, name)
 		if constraint != nil {
-			name = constraint.Name
-		} else if chk != nil {
-			name = chk.Name
+			name = constraint.GetName()
 		}
 
 		m.DB.Raw(
@@ -317,26 +323,44 @@ func (m _Migrator) DropIndex(value interface{}, name string) error {
 	})
 }
 
-func buildConstraint(constraint *schema.Constraint) (sql string, results []interface{}) {
-	sql = "CONSTRAINT ? FOREIGN KEY ? REFERENCES ??"
-	if constraint.OnDelete != "" {
-		sql += " ON DELETE " + constraint.OnDelete
-	}
+type _Index struct {
+	Seq     int
+	Name    string
+	Unique  bool
+	Origin  string
+	Partial bool
+}
 
-	if constraint.OnUpdate != "" {
-		sql += " ON UPDATE " + constraint.OnUpdate
-	}
-
-	var foreignKeys, references []interface{}
-	for _, field := range constraint.ForeignKeys {
-		foreignKeys = append(foreignKeys, clause.Column{Name: field.DBName})
-	}
-
-	for _, field := range constraint.References {
-		references = append(references, clause.Column{Name: field.DBName})
-	}
-	results = append(results, clause.Table{Name: constraint.Name}, foreignKeys, clause.Table{Name: constraint.ReferenceSchema.Table}, references)
-	return
+// GetIndexes return Indexes []gorm.Index and execErr error,
+// See the [doc]
+//
+// [doc]: https://sqlite.org/pragma.html#pragma_index_list
+func (m _Migrator) GetIndexes(value interface{}) ([]gorm.Index, error) {
+	indexes := make([]gorm.Index, 0)
+	err := m.RunWithValue(value, func(stmt *gorm.Statement) error {
+		rst := make([]*_Index, 0)
+		if err := m.DB.Debug().Raw("SELECT * FROM PRAGMA_index_list(?)", stmt.Table).Scan(&rst).Error; err != nil { // alias `PRAGMA index_list(?)`
+			return err
+		}
+		for _, index := range rst {
+			if index.Origin == "u" { // skip the index was created by a UNIQUE constraint
+				continue
+			}
+			var columns []string
+			if err := m.DB.Raw("SELECT name FROM PRAGMA_index_info(?)", index.Name).Scan(&columns).Error; err != nil { // alias `PRAGMA index_info(?)`
+				return err
+			}
+			indexes = append(indexes, &migrator.Index{
+				TableName:       stmt.Table,
+				NameValue:       index.Name,
+				ColumnList:      columns,
+				PrimaryKeyValue: sql.NullBool{Bool: index.Origin == "pk", Valid: true}, // The exceptions are INTEGER PRIMARY KEY
+				UniqueValue:     sql.NullBool{Bool: index.Unique, Valid: true},
+			})
+		}
+		return nil
+	})
+	return indexes, err
 }
 
 func (m _Migrator) getRawDDL(table string) (string, error) {

gormlite/sqlite.go

@@ -2,7 +2,6 @@
 package gormlite
 
 import (
-	"context"
 	"database/sql"
 	"strconv"
 
@@ -13,7 +12,6 @@ import (
 	"gorm.io/gorm/migrator"
 	"gorm.io/gorm/schema"
 
-	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/driver"
 )
 
@@ -40,32 +38,19 @@ func (dialector _Dialector) Initialize(db *gorm.DB) (err error) {
 	if dialector.Conn != nil {
 		db.ConnPool = dialector.Conn
 	} else {
-		conn, err := driver.Open(dialector.DSN, func(c *sqlite3.Conn) error {
-			return c.Exec("PRAGMA foreign_keys = ON")
-		})
+		conn, err := driver.Open(dialector.DSN, nil)
 		if err != nil {
 			return err
 		}
 		db.ConnPool = conn
 	}
 
-	var version string
-	if err := db.ConnPool.QueryRowContext(context.Background(), "select sqlite_version()").Scan(&version); err != nil {
-		return err
-	}
-	// https://sqlite.org/releaselog/3_35_0.html
-	if compareVersion(version, "3.35.0") >= 0 {
-		callbacks.RegisterDefaultCallbacks(db, &callbacks.Config{
-			CreateClauses:        []string{"INSERT", "VALUES", "ON CONFLICT", "RETURNING"},
-			UpdateClauses:        []string{"UPDATE", "SET", "FROM", "WHERE", "RETURNING"},
-			DeleteClauses:        []string{"DELETE", "FROM", "WHERE", "RETURNING"},
-			LastInsertIDReversed: true,
-		})
-	} else {
-		callbacks.RegisterDefaultCallbacks(db, &callbacks.Config{
-			LastInsertIDReversed: true,
-		})
-	}
+	callbacks.RegisterDefaultCallbacks(db, &callbacks.Config{
+		CreateClauses:        []string{"INSERT", "VALUES", "ON CONFLICT", "RETURNING"},
+		UpdateClauses:        []string{"UPDATE", "SET", "FROM", "WHERE", "RETURNING"},
+		DeleteClauses:        []string{"DELETE", "FROM", "WHERE", "RETURNING"},
+		LastInsertIDReversed: true,
+	})
 
 	for k, v := range dialector.ClauseBuilders() {
 		db.ClauseBuilders[k] = v
@@ -234,27 +219,3 @@ func (dialectopr _Dialector) RollbackTo(tx *gorm.DB, name string) error {
 	tx.Exec("ROLLBACK TO SAVEPOINT " + name)
 	return nil
 }
-
-func compareVersion(version1, version2 string) int {
-	n, m := len(version1), len(version2)
-	i, j := 0, 0
-	for i < n || j < m {
-		x := 0
-		for ; i < n && version1[i] != '.'; i++ {
-			x = x*10 + int(version1[i]-'0')
-		}
-		i++
-		y := 0
-		for ; j < m && version2[j] != '.'; j++ {
-			y = y*10 + int(version2[j]-'0')
-		}
-		j++
-		if x > y {
-			return 1
-		}
-		if x < y {
-			return -1
-		}
-	}
-	return 0
-}

gormlite/sqlite_test.go

@@ -9,6 +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/internal/testcfg"
 )
 
 func TestDialector(t *testing.T) {

gormlite/test.sh

@@ -4,7 +4,10 @@ set -euo pipefail
 cd -P -- "$(dirname -- "$0")"
 
 rm -rf gorm/ tests/
-git clone --filter=blob:none https://github.com/go-gorm/gorm.git
+go work use -r .
+go test
+
+git clone --branch v1.25.10 --filter=blob:none https://github.com/go-gorm/gorm.git
 mv gorm/tests tests
 rm -rf gorm/
 

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

@@ -0,0 +1,24 @@
+//go:build !(darwin || linux) || !(amd64 || arm64 || riscv64) || sqlite3_noshm || sqlite3_nosys
+
+package alloc
+
+import "github.com/tetratelabs/wazero/experimental"
+
+func Slice(cap, _ uint64) experimental.LinearMemory {
+	return &sliceMemory{make([]byte, 0, cap)}
+}
+
+type sliceMemory struct {
+	buf []byte
+}
+
+func (b *sliceMemory) Free() {}
+
+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 {
+		b.buf = b.buf[:size]
+	}
+	return b.buf
+}