ci: move to hanzoai/platform (make ci); drop GitHub Actions

Builds/runs/scans on the Hanzo PaaS (Dockerfile/Nixpacks build + scheduled
'make ci' task) instead of GHA. make ci = build + test + govulncheck + gitleaks
+ CycloneDX SBOM. Platform build env has cross-org (hanzoai+luxfi) git creds, so
private modules resolve without the GHA token workaround. Removes .github/workflows.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.github/actions/lfs/action.yml

@@ -1,23 +0,0 @@
-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/actions/vmactions/template.yml

@@ -0,0 +1,11 @@
+name: VM Actions matrix
+description: VM Actions matrix template
+
+runs:
+  using: composite
+  steps:
+    - uses: ${VMACTIONS}
+      with:
+        usesh: true
+        copyback: false
+        run: . ./test.sh

.github/workflows/build-test.sh

@@ -1,11 +0,0 @@
-#!/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,27 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-echo android       ; GOOS=android   GOARCH=amd64 go build .
-echo darwin        ; GOOS=darwin    GOARCH=amd64 go build .
-echo dragonfly     ; GOOS=dragonfly GOARCH=amd64 go build .
-echo freebsd       ; GOOS=freebsd   GOARCH=amd64 go build .
-echo illumos       ; GOOS=illumos   GOARCH=amd64 go build .
-echo ios           ; GOOS=ios       GOARCH=amd64 go build .
-echo linux         ; GOOS=linux     GOARCH=amd64 go build .
-echo netbsd        ; GOOS=netbsd    GOARCH=amd64 go build .
-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 js            ; GOOS=js        GOARCH=wasm  go build .
-echo wasip1        ; GOOS=wasip1    GOARCH=wasm  go build .
-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

@@ -1,16 +0,0 @@
-name: Cross compile
-
-on:
-  workflow_dispatch:
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-go@v5
-      with: { go-version: stable }
-
-    - name: Build
-      run: .github/workflows/cross.sh

.github/workflows/repro.sh

@@ -1,34 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-if [[ "$OSTYPE" == "linux"* ]]; then
-  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-24/wasi-sdk-24.0-x86_64-linux.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_119/binaryen-version_119-x86_64-linux.tar.gz"
-elif [[ "$OSTYPE" == "darwin"* ]]; then
-  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-24/wasi-sdk-24.0-x86_64-macos.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_119/binaryen-version_119-x86_64-macos.tar.gz"
-elif [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" ]]; then
-  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-24/wasi-sdk-24.0-x86_64-windows.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_119/binaryen-version_119-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" ] || curl -#L "$BINARYEN" | tar xzC tools &
-wait
-
-[ -d "tools/wasi-sdk" ] || mv "tools/wasi-sdk"* "tools/wasi-sdk"
-[ -d "tools/binaryen" ] || mv "tools/binaryen"* "tools/binaryen"
-
-# Download and build SQLite
-sqlite3/download.sh
-embed/build.sh
-embed/bcw2/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

@@ -1,34 +0,0 @@
-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: ilammy/msvc-dev-cmd@v1
-    - uses: actions/checkout@v4
-    - uses: actions/setup-go@v5
-      with: { go-version: stable }
-
-    - name: Build
-      shell: bash
-      run: .github/workflows/repro.sh
-
-    - uses: actions/attest-build-provenance@v1
-      if: matrix.os == 'ubuntu-latest'
-      with:
-        subject-path: |
-          embed/sqlite3.wasm
-          embed/bcw2/bcw2.wasm
-          util/vtabutil/parse/sql3parse_table.wasm

.github/workflows/test.yml

@@ -1,196 +0,0 @@
-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 -tags 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
-      shell: bash
-      run: gormlite/test.sh
-
-    - name: Collect coverage
-      run: |
-        go install github.com/dave/courtney@latest
-        courtney
-      if: |
-        github.event_name == 'push' &&
-        matrix.os == 'ubuntu-latest'
-
-    - uses: ncruces/go-coverage-report@v0
-      with:
-        coverage-file: coverage.out
-        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:
-    strategy:
-      matrix:
-        os:
-          - name: freebsd
-            version: '14.1'
-            flags: '-test.v'
-          - name: openbsd
-            version: '7.5'
-            flags: '-test.v -test.short'
-          - name: netbsd
-            version: '10.0'
-            flags: '-test.v -test.short'
-    runs-on: ubuntu-latest
-    needs: test
-
-    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: ${{ matrix.os.name }}
-        TESTFLAGS: ${{ matrix.os.flags }}
-      run: .github/workflows/build-test.sh
-
-    - name: Test
-      uses: cross-platform-actions/action@v0.25.0
-      with:
-        operating_system: ${{ matrix.os.name }}
-        version: ${{ matrix.os.version }}
-        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

.gitignore

@@ -13,4 +13,11 @@
 
 # Dependency directories (remove the comment below to include it)
 # vendor/
-tools
+tools
+
+# Go workspace file
+go.work
+go.work.sum
+
+# env file
+.env

.gitleaks.toml

@@ -0,0 +1,20 @@
+# Fork of ncruces/go-sqlite3. Allowlist UPSTREAM test fixtures + example crypto
+# keys (SHA-256/MD5 of the empty string used in the adiantum/XTS VFS tests, and
+# the SQLite C amalgamation). Hanzo additions (hanzovfs/, cmd/) are still scanned.
+[extend]
+useDefault = true
+
+[allowlist]
+description = "Upstream SQLite + crypto-VFS test fixtures (not real secrets)"
+paths = [
+  '''sqlite3/sqlite3\.c''',
+  '''sqlite3/sqlite3ext\.h''',
+  '''vfs/adiantum/.*''',
+  '''vfs/xts/.*''',
+  '''vfs/tests/.*''',
+  '''tests/.*''',
+]
+regexes = [
+  '''e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855''',
+  '''d41d8cd98f00b204e9800998ecf8427e''',
+]

Makefile

@@ -0,0 +1,35 @@
+# CI/CD for hanzoai/platform (the Hanzo PaaS) — NOT GitHub Actions.
+# The platform runs `make ci` as a build step and/or a scheduled (cron) task.
+# Works identically locally and anywhere: `make ci`.
+SHELL := /usr/bin/env bash
+export GOPRIVATE := github.com/hanzoai,github.com/luxfi
+export GOFLAGS  := -mod=mod
+BIN  := $(CURDIR)/.bin
+export PATH := $(BIN):$(PATH)
+GITLEAKS_VERSION ?= 8.21.2
+ARCH := $(shell uname -m | sed 's/x86_64/x64/; s/aarch64/arm64/')
+
+.PHONY: ci build test scan vuln secrets sbom tools clean
+ci: build test scan            ## full pipeline (build -> test -> scan)
+build:
+	go build ./...
+test:
+	go test ./...
+scan: vuln secrets sbom
+vuln:
+	go install golang.org/x/vuln/cmd/govulncheck@latest
+	govulncheck ./...
+secrets: $(BIN)/gitleaks
+	gitleaks detect --source . --redact --no-banner --exit-code 1
+sbom: $(BIN)/syft
+	syft . -o cyclonedx-json=sbom.cyclonedx.json -q
+tools: $(BIN)/gitleaks $(BIN)/syft
+clean:
+	rm -rf $(BIN) sbom.cyclonedx.json
+
+$(BIN)/gitleaks:
+	@mkdir -p $(BIN)
+	curl -sSfL "https://github.com/gitleaks/gitleaks/releases/download/v$(GITLEAKS_VERSION)/gitleaks_$(GITLEAKS_VERSION)_linux_$(ARCH).tar.gz" | tar -xz -C $(BIN) gitleaks
+$(BIN)/syft:
+	@mkdir -p $(BIN)
+	curl -sSfL https://raw.githubusercontent.com/anchore/syft/main/install.sh | sh -s -- -b $(BIN) >/dev/null

NOTICE

@@ -0,0 +1,7 @@
+github.com/hanzoai/sqlite3 — canonical Hanzo SQLite.
+
+Fork of github.com/ncruces/go-sqlite3 (MIT, Copyright (c) 2023 Nuno Cruces).
+The upstream MIT LICENSE is retained in full. Hanzo additions (the hanzovfs
+native encrypted VFS, module path, build pins) are likewise MIT-licensed.
+
+Pure-Go, no cgo. WASM SQLite blob from github.com/ncruces/go-sqlite3-wasm (upstream).

PLATFORM.md

@@ -0,0 +1,15 @@
+# CI/CD on hanzoai/platform — no GitHub Actions
+
+This repo is built, run, and scanned by **hanzoai/platform** (the Hanzo PaaS),
+not GitHub Actions. `.github/workflows` is intentionally absent.
+
+- **Build / run** — the platform builds via Dockerfile / Nixpacks / Railpack and
+  runs the result; auto-deploy on push.
+- **Actions (CI)** — a platform **Scheduled Task** (and/or build step) runs
+  `make ci` = `build → test → scan` (govulncheck + gitleaks + CycloneDX SBOM),
+  on push and on a cron. SOC 2 CC7.x/CC8.x evidence (artifacts to hanzoai/audit).
+- The platform build env carries Git credentials for `github.com/hanzoai` +
+  `github.com/luxfi`, so cross-org private modules resolve natively — no per-repo
+  token dance (the thing that made GitHub Actions painful).
+
+Run anywhere: `make ci`.

README.md

@@ -1,4 +1,4 @@
-# Go bindings to SQLite using Wazero
+# Go bindings to SQLite using wasm2go
 
 [![Go Reference](https://pkg.go.dev/badge/image)](https://pkg.go.dev/github.com/ncruces/go-sqlite3)
 [![Go Report](https://goreportcard.com/badge/github.com/ncruces/go-sqlite3)](https://goreportcard.com/report/github.com/ncruces/go-sqlite3)
@@ -8,9 +8,9 @@ Go module `github.com/ncruces/go-sqlite3` is a `cgo`-free [SQLite](https://sqlit
 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].
+It wraps a [Wasm](https://webassembly.org/) build of SQLite,
+and uses [wasm2go](https://github.com/ncruces/wasm2go) to translate it to Go.\
+Go and [`x/sys`](https://pkg.go.dev/golang.org/x/sys) are the _only_ direct dependencies.
 
 ### Getting started
 
@@ -19,7 +19,6 @@ Using the [`database/sql`](https://pkg.go.dev/database/sql) driver:
 
 import "database/sql"
 import _ "github.com/ncruces/go-sqlite3/driver"
-import _ "github.com/ncruces/go-sqlite3/embed"
 
 var version string
 db, _ := sql.Open("sqlite3", "file:demo.db")
@@ -30,105 +29,115 @@ db.QueryRow(`SELECT sqlite_version()`).Scan(&version)
 
 - [`github.com/ncruces/go-sqlite3`](https://pkg.go.dev/github.com/ncruces/go-sqlite3)
   wraps the [C SQLite API](https://sqlite.org/cintro.html)
-  ([example usage](https://pkg.go.dev/github.com/ncruces/go-sqlite3#example-package)).
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3#example-package)).
 - [`github.com/ncruces/go-sqlite3/driver`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver)
   provides a [`database/sql`](https://pkg.go.dev/database/sql) driver
-  ([example usage](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#example-package)).
-- [`github.com/ncruces/go-sqlite3/embed`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/embed)
-  embeds a build of SQLite into your application.
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#example-package)).
 - [`github.com/ncruces/go-sqlite3/vfs`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs)
   wraps the [C SQLite VFS API](https://sqlite.org/vfs.html) and provides a pure Go implementation.
 - [`github.com/ncruces/go-sqlite3/gormlite`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/gormlite)
   provides a [GORM](https://gorm.io) driver.
 
-### Extensions
-
-- [`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/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 data [line-by-line](https://github.com/asg017/sqlite-lines).
-- [`github.com/ncruces/go-sqlite3/ext/pivot`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/pivot)
-  creates [pivot tables](https://github.com/jakethaw/pivot_vtab).
-- [`github.com/ncruces/go-sqlite3/ext/regexp`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/regexp)
-  provides regular expression functions.
-- [`github.com/ncruces/go-sqlite3/ext/statement`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/statement)
-  creates [parameterized views](https://github.com/0x09/sqlite-statement-vtab).
-- [`github.com/ncruces/go-sqlite3/ext/stats`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/stats)
-  provides [statistics](https://www.oreilly.com/library/view/sql-in-a/9780596155322/ch04s02.html) functions.
-- [`github.com/ncruces/go-sqlite3/ext/unicode`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/unicode)
-  provides [Unicode aware](https://sqlite.org/src/dir/ext/icu) functions.
-- [`github.com/ncruces/go-sqlite3/ext/uuid`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/uuid)
-  generates [UUIDs](https://en.wikipedia.org/wiki/Universally_unique_identifier).
-- [`github.com/ncruces/go-sqlite3/ext/zorder`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/zorder)
-  maps multidimensional data to one dimension.
-- [`github.com/ncruces/go-sqlite3/vfs/adiantum`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/adiantum)
-  wraps a VFS to offer encryption at rest.
-- [`github.com/ncruces/go-sqlite3/vfs/memdb`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/memdb)
-  implements an in-memory VFS.
-- [`github.com/ncruces/go-sqlite3/vfs/readervfs`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/readervfs)
-  implements a VFS for immutable databases.
-
 ### Advanced features
 
 - [incremental BLOB I/O](https://sqlite.org/c3ref/blob_open.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/blobio#example-package))
 - [nested transactions](https://sqlite.org/lang_savepoint.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#example-Savepoint))
 - [custom functions](https://sqlite.org/c3ref/create_function.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3#example-Conn.CreateFunction))
 - [virtual tables](https://sqlite.org/vtab.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3#example-CreateModule))
 - [custom VFSes](https://sqlite.org/vfs.html)
+  ([examples](vfs/README.md#custom-vfses))
 - [online backup](https://sqlite.org/backup.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#Conn))
 - [JSON support](https://sqlite.org/json1.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#example-package-Json))
 - [math functions](https://sqlite.org/lang_mathfunc.html)
-- [full-text search](https://sqlite.org/fts5.html)
-- [geospatial search](https://sqlite.org/geopoly.html)
+- [Unicode support](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/unicode)
+- [statistics functions](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/stats)
 - [encryption at rest](vfs/adiantum/README.md)
-- [and more…](embed/README.md)
+- [many extensions](ext/README.md)
 
 ### Caveats
 
 This module replaces the SQLite [OS Interface](https://sqlite.org/vfs.html)
 (aka VFS) with a [pure Go](vfs/) implementation,
 which has advantages and disadvantages.
-
 Read more about the Go VFS design [here](vfs/README.md).
 
+Because each database connection executes within a Wasm sandboxed environment,
+memory usage will be higher than alternatives.
+
 ### Testing
 
 This project aims for [high test coverage](https://github.com/ncruces/go-sqlite3/wiki/Test-coverage-report).
-It also benefits greatly from [SQLite's](https://sqlite.org/testing.html) and
-[wazero's](https://tetrate.io/blog/introducing-wazero-from-tetrate/#:~:text=Rock%2Dsolid%20test%20approach) thorough testing.
+It also benefits greatly from [SQLite's](https://sqlite.org/testing.html) thorough testing.
 
-Every commit is [tested](https://github.com/ncruces/go-sqlite3/wiki/Test-matrix) on
-Linux (amd64/arm64/386/riscv64/s390x), macOS (amd64/arm64),
-Windows (amd64), FreeBSD (amd64), OpenBSD (amd64), NetBSD (amd64),
-illumos (amd64), and Solaris (amd64).
+Every commit is tested on:
+* Linux: amd64, arm64, 386, arm, riscv64, ppc64le, loong64, s390x
+* macOS: amd64, arm64
+* Windows: amd64, arm64
+* BSD:
+  * FreeBSD: amd64, arm64
+  * NetBSD: amd64, arm64
+  * DragonFly BSD: amd64
+  * OpenBSD: amd64
+* illumos: amd64
+* Solaris: amd64
+
+Certain operating system and CPU combinations have some limitations.
+See the [support matrix](https://github.com/ncruces/go-sqlite3/wiki/Support-matrix) for a complete overview.
 
 The Go VFS is tested by running SQLite's
 [mptest](https://github.com/sqlite/sqlite/blob/master/mptest/mptest.c).
 
 ### Performance
 
-Perfomance of the [`database/sql`](https://pkg.go.dev/database/sql) driver is
+Performance of the [`database/sql`](https://pkg.go.dev/database/sql) driver is
 [competitive](https://github.com/cvilsmeier/go-sqlite-bench) with alternatives.
 
-The Wasm and VFS layers are also tested by running SQLite's
+The Wasm and VFS layers are also benchmarked by running SQLite's
 [speedtest1](https://github.com/sqlite/sqlite/blob/master/test/speedtest1.c).
 
-### Alternatives
+### Concurrency
 
-- [`modernc.org/sqlite`](https://pkg.go.dev/modernc.org/sqlite)
-- [`crawshaw.io/sqlite`](https://pkg.go.dev/crawshaw.io/sqlite)
-- [`github.com/mattn/go-sqlite3`](https://pkg.go.dev/github.com/mattn/go-sqlite3)
-- [`github.com/zombiezen/go-sqlite`](https://pkg.go.dev/github.com/zombiezen/go-sqlite)
+This module behaves similarly to SQLite in [multi-thread](https://sqlite.org/threadsafe.html) mode:
+it is goroutine-safe, provided that no single database connection, or object derived from it,
+is used concurrently by multiple goroutines.
 
-[^1]: anything else you find in `go.mod` is either a test dependency,
-      or needed by one of the extensions.
+The [`database/sql`](https://pkg.go.dev/database/sql) API is safe to use concurrently,
+according to its documentation.
+
+### FAQ, issues, new features
+
+For questions, please see [Discussions](https://github.com/ncruces/go-sqlite3/discussions/categories/q-a).
+
+Also, post there if you used this driver for something interesting
+([_"Show and tell"_](https://github.com/ncruces/go-sqlite3/discussions/categories/show-and-tell)),
+have an [idea](https://github.com/ncruces/go-sqlite3/discussions/categories/ideas)…
+
+The [Issue](https://github.com/ncruces/go-sqlite3/issues) tracker is for bugs,
+and features we're working on, planning to work on, or asking for help with.
+
+---
+
+## Hanzo fork
+
+`github.com/hanzoai/sqlite3` is the **canonical Hanzo SQLite** — a fork of
+`ncruces/go-sqlite3` (MIT) adding the **`hanzovfs`** native encrypted VFS for
+per-tenant SQLite ⇒ `hanzoai/vfs` ⇒ S3 (HIP-0302 / HIP-0107), no FUSE, no cgo.
+
+```go
+import (
+    "github.com/hanzoai/sqlite3"
+    _ "github.com/hanzoai/sqlite3/hanzovfs" // registers vfs=hanzo
+    _ "github.com/hanzoai/sqlite3/embed"
+)
+db, _ := sqlite3.Open("file:/orgs/acme/app.db?vfs=hanzo")
+```
+
+**Deprecates** `modernc.org/sqlite` (no custom-VFS hook) and direct use of
+`ncruces/go-sqlite3`. Benchmarked 3.6× faster writes / ~92× faster point-reads
+than the FUSE-mounted path; per-page AEAD encryption costs ~0.

backup.go

@@ -5,8 +5,8 @@ package sqlite3
 // https://sqlite.org/c3ref/backup.html
 type Backup struct {
 	c      *Conn
-	handle uint32
-	otherc uint32
+	handle ptr_t
+	otherc ptr_t
 }
 
 // Backup backs up srcDB on the src connection to the "main" database in dstURI.
@@ -61,29 +61,29 @@ func (src *Conn) BackupInit(srcDB, dstURI string) (*Backup, error) {
 	return src.backupInit(dst, "main", src.handle, srcDB)
 }
 
-func (c *Conn) backupInit(dst uint32, dstName string, src uint32, srcName string) (*Backup, error) {
-	defer c.arena.mark()()
-	dstPtr := c.arena.string(dstName)
-	srcPtr := c.arena.string(srcName)
+func (c *Conn) backupInit(dst ptr_t, dstName string, src ptr_t, srcName string) (*Backup, error) {
+	defer c.arena.Mark()()
+	dstPtr := c.arena.String(dstName)
+	srcPtr := c.arena.String(srcName)
 
 	other := dst
 	if c.handle == dst {
 		other = src
 	}
 
-	r := c.call("sqlite3_backup_init",
-		uint64(dst), uint64(dstPtr),
-		uint64(src), uint64(srcPtr))
-	if r == 0 {
+	ptr := ptr_t(c.wrp.Xsqlite3_backup_init(
+		int32(dst), int32(dstPtr),
+		int32(src), int32(srcPtr)))
+	if ptr == 0 {
 		defer c.closeDB(other)
-		r = c.call("sqlite3_errcode", uint64(dst))
-		return nil, c.sqlite.error(r, dst)
+		rc := res_t(c.wrp.Xsqlite3_errcode(int32(dst)))
+		return nil, c.errorFor(dst, rc)
 	}
 
 	return &Backup{
 		c:      c,
 		otherc: other,
-		handle: uint32(r),
+		handle: ptr,
 	}, nil
 }
 
@@ -97,10 +97,10 @@ func (b *Backup) Close() error {
 		return nil
 	}
 
-	r := b.c.call("sqlite3_backup_finish", uint64(b.handle))
+	rc := res_t(b.c.wrp.Xsqlite3_backup_finish(int32(b.handle)))
 	b.c.closeDB(b.otherc)
 	b.handle = 0
-	return b.c.error(r)
+	return b.c.error(rc)
 }
 
 // Step copies up to nPage pages between the source and destination databases.
@@ -108,11 +108,11 @@ 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("sqlite3_backup_step", uint64(b.handle), uint64(nPage))
-	if r == _DONE {
+	rc := res_t(b.c.wrp.Xsqlite3_backup_step(int32(b.handle), int32(nPage)))
+	if rc == _DONE {
 		return true, nil
 	}
-	return false, b.c.error(r)
+	return false, b.c.error(rc)
 }
 
 // Remaining returns the number of pages still to be backed up
@@ -120,8 +120,7 @@ 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("sqlite3_backup_remaining", uint64(b.handle))
-	return int(int32(r))
+	return int(b.c.wrp.Xsqlite3_backup_remaining(int32(b.handle)))
 }
 
 // PageCount returns the total number of pages in the source database
@@ -129,6 +128,5 @@ func (b *Backup) Remaining() int {
 //
 // https://sqlite.org/c3ref/backup_finish.html#sqlite3backuppagecount
 func (b *Backup) PageCount() int {
-	r := b.c.call("sqlite3_backup_pagecount", uint64(b.handle))
-	return int(int32(r))
+	return int(b.c.wrp.Xsqlite3_backup_pagecount(int32(b.handle)))
 }

blob.go

@@ -3,7 +3,7 @@ package sqlite3
 import (
 	"io"
 
-	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/hanzoai/sqlite3/internal/errutil"
 )
 
 // ZeroBlob represents a zero-filled, length n BLOB
@@ -20,8 +20,8 @@ type Blob struct {
 	c      *Conn
 	bytes  int64
 	offset int64
-	handle uint32
-	bufptr uint32
+	handle ptr_t
+	bufptr ptr_t
 	buflen int64
 }
 
@@ -31,29 +31,32 @@ var _ io.ReadWriteSeeker = &Blob{}
 //
 // https://sqlite.org/c3ref/blob_open.html
 func (c *Conn) OpenBlob(db, table, column string, row int64, write bool) (*Blob, error) {
-	c.checkInterrupt()
-	defer c.arena.mark()()
-	blobPtr := c.arena.new(ptrlen)
-	dbPtr := c.arena.string(db)
-	tablePtr := c.arena.string(table)
-	columnPtr := c.arena.string(column)
+	if c.interrupt.Err() != nil {
+		return nil, INTERRUPT
+	}
 
-	var flags uint64
+	defer c.arena.Mark()()
+	blobPtr := c.arena.New(ptrlen)
+	dbPtr := c.arena.String(db)
+	tablePtr := c.arena.String(table)
+	columnPtr := c.arena.String(column)
+
+	var flags int32
 	if write {
 		flags = 1
 	}
 
-	r := c.call("sqlite3_blob_open", uint64(c.handle),
-		uint64(dbPtr), uint64(tablePtr), uint64(columnPtr),
-		uint64(row), flags, uint64(blobPtr))
+	rc := res_t(c.wrp.Xsqlite3_blob_open(int32(c.handle),
+		int32(dbPtr), int32(tablePtr), int32(columnPtr),
+		row, flags, int32(blobPtr)))
 
-	if err := c.error(r); err != nil {
+	if err := c.error(rc); err != nil {
 		return nil, err
 	}
 
 	blob := Blob{c: c}
-	blob.handle = util.ReadUint32(c.mod, blobPtr)
-	blob.bytes = int64(c.call("sqlite3_blob_bytes", uint64(blob.handle)))
+	blob.handle = ptr_t(c.wrp.Read32(blobPtr))
+	blob.bytes = int64(c.wrp.Xsqlite3_blob_bytes(int32(blob.handle)))
 	return &blob, nil
 }
 
@@ -67,10 +70,10 @@ func (b *Blob) Close() error {
 		return nil
 	}
 
-	r := b.c.call("sqlite3_blob_close", uint64(b.handle))
-	b.c.free(b.bufptr)
+	rc := res_t(b.c.wrp.Xsqlite3_blob_close(int32(b.handle)))
+	b.c.wrp.Free(b.bufptr)
 	b.handle = 0
-	return b.c.error(r)
+	return b.c.error(rc)
 }
 
 // Size returns the size of the BLOB in bytes.
@@ -94,13 +97,13 @@ func (b *Blob) Read(p []byte) (n int, err error) {
 		want = avail
 	}
 	if want > b.buflen {
-		b.bufptr = b.c.realloc(b.bufptr, uint64(want))
+		b.bufptr = b.c.wrp.Realloc(b.bufptr, want)
 		b.buflen = want
 	}
 
-	r := b.c.call("sqlite3_blob_read", uint64(b.handle),
-		uint64(b.bufptr), uint64(want), uint64(b.offset))
-	err = b.c.error(r)
+	rc := res_t(b.c.wrp.Xsqlite3_blob_read(int32(b.handle),
+		int32(b.bufptr), int32(want), int32(b.offset)))
+	err = b.c.error(rc)
 	if err != nil {
 		return 0, err
 	}
@@ -109,7 +112,7 @@ func (b *Blob) Read(p []byte) (n int, err error) {
 		err = io.EOF
 	}
 
-	copy(p, util.View(b.c.mod, b.bufptr, uint64(want)))
+	copy(p, b.c.wrp.Bytes(b.bufptr, want))
 	return int(want), err
 }
 
@@ -127,19 +130,19 @@ func (b *Blob) WriteTo(w io.Writer) (n int64, err error) {
 		want = avail
 	}
 	if want > b.buflen {
-		b.bufptr = b.c.realloc(b.bufptr, uint64(want))
+		b.bufptr = b.c.wrp.Realloc(b.bufptr, want)
 		b.buflen = want
 	}
 
 	for want > 0 {
-		r := b.c.call("sqlite3_blob_read", uint64(b.handle),
-			uint64(b.bufptr), uint64(want), uint64(b.offset))
-		err = b.c.error(r)
+		rc := res_t(b.c.wrp.Xsqlite3_blob_read(int32(b.handle),
+			int32(b.bufptr), int32(want), int32(b.offset)))
+		err = b.c.error(rc)
 		if err != nil {
 			return n, err
 		}
 
-		mem := util.View(b.c.mod, b.bufptr, uint64(want))
+		mem := b.c.wrp.Bytes(b.bufptr, want)
 		m, err := w.Write(mem[:want])
 		b.offset += int64(m)
 		n += int64(m)
@@ -165,14 +168,14 @@ func (b *Blob) WriteTo(w io.Writer) (n int64, err error) {
 func (b *Blob) Write(p []byte) (n int, err error) {
 	want := int64(len(p))
 	if want > b.buflen {
-		b.bufptr = b.c.realloc(b.bufptr, uint64(want))
+		b.bufptr = b.c.wrp.Realloc(b.bufptr, want)
 		b.buflen = want
 	}
-	util.WriteBytes(b.c.mod, b.bufptr, p)
+	b.c.wrp.WriteBytes(b.bufptr, p)
 
-	r := b.c.call("sqlite3_blob_write", uint64(b.handle),
-		uint64(b.bufptr), uint64(want), uint64(b.offset))
-	err = b.c.error(r)
+	rc := res_t(b.c.wrp.Xsqlite3_blob_write(int32(b.handle),
+		int32(b.bufptr), int32(want), int32(b.offset)))
+	err = b.c.error(rc)
 	if err != nil {
 		return 0, err
 	}
@@ -196,17 +199,17 @@ func (b *Blob) ReadFrom(r io.Reader) (n int64, err error) {
 		want = 1
 	}
 	if want > b.buflen {
-		b.bufptr = b.c.realloc(b.bufptr, uint64(want))
+		b.bufptr = b.c.wrp.Realloc(b.bufptr, want)
 		b.buflen = want
 	}
 
 	for {
-		mem := util.View(b.c.mod, b.bufptr, uint64(want))
+		mem := b.c.wrp.Bytes(b.bufptr, want)
 		m, err := r.Read(mem[:want])
 		if m > 0 {
-			r := b.c.call("sqlite3_blob_write", uint64(b.handle),
-				uint64(b.bufptr), uint64(m), uint64(b.offset))
-			err := b.c.error(r)
+			rc := res_t(b.c.wrp.Xsqlite3_blob_write(int32(b.handle),
+				int32(b.bufptr), int32(m), int32(b.offset)))
+			err := b.c.error(rc)
 			if err != nil {
 				return n, err
 			}
@@ -234,7 +237,7 @@ func (b *Blob) ReadFrom(r io.Reader) (n int64, err error) {
 func (b *Blob) Seek(offset int64, whence int) (int64, error) {
 	switch whence {
 	default:
-		return 0, util.WhenceErr
+		return 0, errutil.WhenceErr
 	case io.SeekStart:
 		break
 	case io.SeekCurrent:
@@ -243,7 +246,7 @@ func (b *Blob) Seek(offset int64, whence int) (int64, error) {
 		offset += b.bytes
 	}
 	if offset < 0 {
-		return 0, util.OffsetErr
+		return 0, errutil.OffsetErr
 	}
 	b.offset = offset
 	return offset, nil
@@ -253,8 +256,11 @@ 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("sqlite3_blob_reopen", uint64(b.handle), uint64(row)))
-	b.bytes = int64(b.c.call("sqlite3_blob_bytes", uint64(b.handle)))
+	if b.c.interrupt.Err() != nil {
+		return INTERRUPT
+	}
+	err := b.c.error(res_t(b.c.wrp.Xsqlite3_blob_reopen(int32(b.handle), row)))
+	b.bytes = int64(b.c.wrp.Xsqlite3_blob_bytes(int32(b.handle)))
 	b.offset = 0
 	return err
 }

cmd/hanzovfs-bench/main.go

@@ -0,0 +1,48 @@
+// hanzovfs-bench: native PQ SQLite VFS throughput (in-process, no FUSE).
+//   go run github.com/hanzoai/sqlite3/cmd/hanzovfs-bench@latest
+package main
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"time"
+
+	"github.com/hanzoai/sqlite3"
+	_ "github.com/hanzoai/sqlite3/embed"
+	"github.com/hanzoai/sqlite3/hanzovfs"
+	"github.com/luxfi/age"
+)
+
+func bench(label, dsn string) {
+	db, err := sqlite3.Open(dsn)
+	if err != nil { fmt.Printf("%-24s OPEN ERR %v\n", label, err); return }
+	defer db.Close()
+	db.Exec(`PRAGMA journal_mode=MEMORY; PRAGMA synchronous=OFF;`)
+	db.Exec(`CREATE TABLE t(id INTEGER PRIMARY KEY, email TEXT, body TEXT)`)
+	const n = 20000
+	t0 := time.Now()
+	db.Exec("BEGIN")
+	st, _, _ := db.Prepare("INSERT INTO t(email,body) VALUES(?,?)")
+	for i := 0; i < n; i++ {
+		st.BindText(1, fmt.Sprintf("u%d@hanzo.ai", i))
+		st.BindText(2, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
+		st.Step(); st.Reset()
+	}
+	st.Close(); db.Exec("COMMIT")
+	ins := float64(n) / time.Since(t0).Seconds()
+	t0 = time.Now()
+	sel, _, _ := db.Prepare("SELECT body FROM t WHERE id=?")
+	for i := 0; i < 5000; i++ { sel.BindInt(1, 1+(i*7)%n); sel.Step(); sel.Reset() }
+	sel.Close()
+	fmt.Printf("%-24s insert=%9.0f rows/s   point_sel=%9.0f q/s\n", label, ins, 5000/time.Since(t0).Seconds())
+}
+
+func main() {
+	fmt.Printf("hanzovfs-bench %s/%s (%d CPU)\n", runtime.GOOS, runtime.GOARCH, runtime.NumCPU())
+	id, rcpt, err := hanzovfs.GenerateIdentity()
+	if err != nil { panic(err) }
+	dir, _ := os.MkdirTemp("", "hvfs")
+	hanzovfs.Register("pq", hanzovfs.Config{Dir: dir, Recipients: []age.Recipient{rcpt}, Identities: []age.Identity{id}})
+	bench("native PQ VFS (ML-KEM)", "file:/orgs/acme/bench.db?vfs=pq")
+}

config.go

@@ -1,11 +1,12 @@
 package sqlite3
 
 import (
-	"context"
+	"fmt"
+	"strconv"
+	"sync/atomic"
 
-	"github.com/ncruces/go-sqlite3/internal/util"
-	"github.com/ncruces/go-sqlite3/vfs"
-	"github.com/tetratelabs/wazero/api"
+	"github.com/hanzoai/sqlite3/internal/errutil"
+	"github.com/hanzoai/sqlite3/vfs"
 )
 
 // Config makes configuration changes to a database connection.
@@ -15,10 +16,21 @@ import (
 //
 // 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)
+	if op < DBCONFIG_ENABLE_FKEY || op > DBCONFIG_REVERSE_SCANORDER {
+		return false, MISUSE
+	}
 
-	var flag int
+	// We need to call sqlite3_db_config, a variadic function.
+	// We only support the `int int*` variants.
+	// The int is a three-valued bool: -1 queries, 0/1 sets false/true.
+	// The int* points to where new state will be written to.
+	// The vararg is a pointer to an array containing these arguments:
+	// an int and an int* pointing to that int.
+
+	defer c.arena.Mark()()
+	argsPtr := c.arena.New(intlen + ptrlen)
+
+	var flag int32
 	switch {
 	case len(arg) == 0:
 		flag = -1
@@ -26,128 +38,154 @@ func (c *Conn) Config(op DBConfig, arg ...bool) (bool, error) {
 		flag = 1
 	}
 
-	util.WriteUint32(c.mod, argsPtr+0*ptrlen, uint32(flag))
-	util.WriteUint32(c.mod, argsPtr+1*ptrlen, argsPtr)
+	c.wrp.Write32(argsPtr+0*ptrlen, uint32(flag))
+	c.wrp.Write32(argsPtr+1*ptrlen, uint32(argsPtr))
 
-	r := c.call("sqlite3_db_config", uint64(c.handle),
-		uint64(op), uint64(argsPtr))
-	return util.ReadUint32(c.mod, argsPtr) != 0, c.error(r)
+	rc := res_t(c.wrp.Xsqlite3_db_config(int32(c.handle),
+		int32(op), int32(argsPtr)))
+	return c.wrp.ReadBool(argsPtr), c.error(rc)
+}
+
+var defaultLogger atomic.Pointer[func(code ExtendedErrorCode, msg string)]
+
+// ConfigLog sets up the default error logging callback for new connections.
+//
+// https://sqlite.org/errlog.html
+func ConfigLog(cb func(code ExtendedErrorCode, msg string)) {
+	defaultLogger.Store(&cb)
 }
 
 // ConfigLog sets up the error logging callback for the connection.
 //
 // https://sqlite.org/errlog.html
 func (c *Conn) ConfigLog(cb func(code ExtendedErrorCode, msg string)) error {
-	var enable uint64
+	var enable int32
 	if cb != nil {
 		enable = 1
 	}
-	r := c.call("sqlite3_config_log_go", enable)
-	if err := c.error(r); err != nil {
+	rc := res_t(c.wrp.Xsqlite3_config_log_go(enable))
+	if err := c.error(rc); 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)
+func (e *env) Xgo_log(_, iCode, zMsg int32) {
+	if c, ok := e.DB.(*Conn); ok && c.log != nil {
+		msg := e.ReadString(ptr_t(zMsg), _MAX_LENGTH)
 		c.log(xErrorCode(iCode), msg)
 	}
 }
 
+// Log writes a message into the error log established by [Conn.ConfigLog].
+//
+// https://sqlite.org/c3ref/log.html
+func (c *Conn) Log(code ExtendedErrorCode, format string, a ...any) {
+	if c.log != nil {
+		c.log(code, fmt.Sprintf(format, a...))
+	}
+}
+
 // FileControl allows low-level control of database files.
 // Only a subset of opcodes are supported.
 //
 // https://sqlite.org/c3ref/file_control.html
 func (c *Conn) FileControl(schema string, op FcntlOpcode, arg ...any) (any, error) {
-	defer c.arena.mark()()
+	defer c.arena.Mark()()
+	ptr := c.arena.New(max(ptrlen, intlen))
 
-	var schemaPtr uint32
+	var schemaPtr ptr_t
 	if schema != "" {
-		schemaPtr = c.arena.string(schema)
+		schemaPtr = c.arena.String(schema)
 	}
 
+	var rc res_t
+	var ret any
 	switch op {
-	case FCNTL_RESET_CACHE:
-		r := c.call("sqlite3_file_control",
-			uint64(c.handle), uint64(schemaPtr),
-			uint64(op), 0)
-		return nil, c.error(r)
+	default:
+		return nil, MISUSE
+
+	case FCNTL_RESET_CACHE, FCNTL_NULL_IO:
+		rc = res_t(c.wrp.Xsqlite3_file_control(
+			int32(c.handle), int32(schemaPtr),
+			int32(op), 0))
 
 	case FCNTL_PERSIST_WAL, FCNTL_POWERSAFE_OVERWRITE:
-		var flag int
+		var flag int32
 		switch {
 		case len(arg) == 0:
 			flag = -1
 		case arg[0]:
 			flag = 1
 		}
-		ptr := c.arena.new(4)
-		util.WriteUint32(c.mod, ptr, uint32(flag))
-		r := c.call("sqlite3_file_control",
-			uint64(c.handle), uint64(schemaPtr),
-			uint64(op), uint64(ptr))
-		return util.ReadUint32(c.mod, ptr) != 0, c.error(r)
+		c.wrp.Write32(ptr, uint32(flag))
+		rc = res_t(c.wrp.Xsqlite3_file_control(
+			int32(c.handle), int32(schemaPtr),
+			int32(op), int32(ptr)))
+		ret = c.wrp.ReadBool(ptr)
 
 	case FCNTL_CHUNK_SIZE:
-		ptr := c.arena.new(4)
-		util.WriteUint32(c.mod, ptr, uint32(arg[0].(int)))
-		r := c.call("sqlite3_file_control",
-			uint64(c.handle), uint64(schemaPtr),
-			uint64(op), uint64(ptr))
-		return nil, c.error(r)
+		c.wrp.Write32(ptr, uint32(arg[0].(int)))
+		rc = res_t(c.wrp.Xsqlite3_file_control(
+			int32(c.handle), int32(schemaPtr),
+			int32(op), int32(ptr)))
 
 	case FCNTL_RESERVE_BYTES:
 		bytes := -1
 		if len(arg) > 0 {
 			bytes = arg[0].(int)
 		}
-		ptr := c.arena.new(4)
-		util.WriteUint32(c.mod, ptr, uint32(bytes))
-		r := c.call("sqlite3_file_control",
-			uint64(c.handle), uint64(schemaPtr),
-			uint64(op), uint64(ptr))
-		return int(util.ReadUint32(c.mod, ptr)), c.error(r)
+		c.wrp.Write32(ptr, uint32(bytes))
+		rc = res_t(c.wrp.Xsqlite3_file_control(
+			int32(c.handle), int32(schemaPtr),
+			int32(op), int32(ptr)))
+		ret = int(int32(c.wrp.Read32(ptr)))
 
 	case FCNTL_DATA_VERSION:
-		ptr := c.arena.new(4)
-		r := c.call("sqlite3_file_control",
-			uint64(c.handle), uint64(schemaPtr),
-			uint64(op), uint64(ptr))
-		return util.ReadUint32(c.mod, ptr), c.error(r)
+		rc = res_t(c.wrp.Xsqlite3_file_control(
+			int32(c.handle), int32(schemaPtr),
+			int32(op), int32(ptr)))
+		ret = c.wrp.Read32(ptr)
 
 	case FCNTL_LOCKSTATE:
-		ptr := c.arena.new(4)
-		r := c.call("sqlite3_file_control",
-			uint64(c.handle), uint64(schemaPtr),
-			uint64(op), uint64(ptr))
-		return vfs.LockLevel(util.ReadUint32(c.mod, ptr)), c.error(r)
+		rc = res_t(c.wrp.Xsqlite3_file_control(
+			int32(c.handle), int32(schemaPtr),
+			int32(op), int32(ptr)))
+		ret = vfs.LockLevel(c.wrp.Read32(ptr))
 
-	case FCNTL_VFS_POINTER:
-		ptr := c.arena.new(4)
-		r := c.call("sqlite3_file_control",
-			uint64(c.handle), uint64(schemaPtr),
-			uint64(op), uint64(ptr))
-		const zNameOffset = 16
-		ptr = util.ReadUint32(c.mod, ptr)
-		ptr = util.ReadUint32(c.mod, ptr+zNameOffset)
-		name := util.ReadString(c.mod, ptr, _MAX_NAME)
-		return vfs.Find(name), c.error(r)
+	case FCNTL_VFSNAME, FCNTL_VFS_POINTER:
+		rc = res_t(c.wrp.Xsqlite3_file_control(
+			int32(c.handle), int32(schemaPtr),
+			int32(FCNTL_VFS_POINTER), int32(ptr)))
+		if rc == _OK {
+			const zNameOffset = 16
+			ptr = ptr_t(c.wrp.Read32(ptr))
+			ptr = ptr_t(c.wrp.Read32(ptr + zNameOffset))
+			name := c.wrp.ReadString(ptr, _MAX_NAME)
+			if op == FCNTL_VFS_POINTER {
+				ret = vfs.Find(name)
+			} else {
+				ret = name
+			}
+		}
 
 	case FCNTL_FILE_POINTER, FCNTL_JOURNAL_POINTER:
-		ptr := c.arena.new(4)
-		r := c.call("sqlite3_file_control",
-			uint64(c.handle), uint64(schemaPtr),
-			uint64(op), uint64(ptr))
-		const fileHandleOffset = 4
-		ptr = util.ReadUint32(c.mod, ptr)
-		ptr = util.ReadUint32(c.mod, ptr+fileHandleOffset)
-		return util.GetHandle(c.ctx, ptr), c.error(r)
+		rc = res_t(c.wrp.Xsqlite3_file_control(
+			int32(c.handle), int32(schemaPtr),
+			int32(op), int32(ptr)))
+		if rc == _OK {
+			const fileHandleOffset = 4
+			ptr = ptr_t(c.wrp.Read32(ptr))
+			ptr = ptr_t(c.wrp.Read32(ptr + fileHandleOffset))
+			ret = c.wrp.GetHandle(ptr)
+		}
 	}
 
-	return nil, MISUSE
+	if err := c.error(rc); err != nil {
+		return nil, err
+	}
+	return ret, nil
 }
 
 // Limit allows the size of various constructs to be
@@ -155,156 +193,205 @@ func (c *Conn) FileControl(schema string, op FcntlOpcode, arg ...any) (any, erro
 //
 // 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))
+	return int(c.wrp.Xsqlite3_limit(int32(c.handle), int32(id), int32(value)))
 }
 
 // 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, inner string) AuthorizerReturnCode) error {
-	var enable uint64
+	var enable int32
 	if cb != nil {
 		enable = 1
 	}
-	r := c.call("sqlite3_set_authorizer_go", uint64(c.handle), enable)
-	if err := c.error(r); err != nil {
+	rc := res_t(c.wrp.Xsqlite3_set_authorizer_go(int32(c.handle), enable))
+	if err := c.error(rc); err != nil {
 		return err
 	}
 	c.authorizer = cb
 	return nil
-
 }
 
-func authorizerCallback(ctx context.Context, mod api.Module, pDB uint32, action AuthorizerActionCode, zName3rd, zName4th, zSchema, zInner uint32) (rc AuthorizerReturnCode) {
-	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.authorizer != nil {
+func (e *env) Xgo_authorizer(pDB, action, zName3rd, zName4th, zSchema, zInner int32) (rc int32) {
+	if c, ok := e.DB.(*Conn); ok && c.handle == ptr_t(pDB) && c.authorizer != nil {
 		var name3rd, name4th, schema, inner string
 		if zName3rd != 0 {
-			name3rd = util.ReadString(mod, zName3rd, _MAX_NAME)
+			name3rd = e.ReadString(ptr_t(zName3rd), _MAX_NAME)
 		}
 		if zName4th != 0 {
-			name4th = util.ReadString(mod, zName4th, _MAX_NAME)
+			name4th = e.ReadString(ptr_t(zName4th), _MAX_NAME)
 		}
 		if zSchema != 0 {
-			schema = util.ReadString(mod, zSchema, _MAX_NAME)
+			schema = e.ReadString(ptr_t(zSchema), _MAX_NAME)
 		}
 		if zInner != 0 {
-			inner = util.ReadString(mod, zInner, _MAX_NAME)
+			inner = e.ReadString(ptr_t(zInner), _MAX_NAME)
 		}
-		rc = c.authorizer(action, name3rd, name4th, schema, inner)
+		return int32(c.authorizer(AuthorizerActionCode(action), name3rd, name4th, schema, inner))
 	}
-	return rc
+	return _OK
 }
 
 // Trace registers a trace callback function against the database connection.
 //
 // https://sqlite.org/c3ref/trace_v2.html
-func (c *Conn) Trace(mask TraceEvent, cb func(evt TraceEvent, arg1 any, arg2 any) error) error {
-	r := c.call("sqlite3_trace_go", uint64(c.handle), uint64(mask))
-	if err := c.error(r); err != nil {
+func (c *Conn) Trace(mask TraceEvent, cb func(evt TraceEvent, arg1, arg2 any) error) error {
+	rc := res_t(c.wrp.Xsqlite3_trace_go(int32(c.handle), int32(mask)))
+	if err := c.error(rc); err != nil {
 		return err
 	}
 	c.trace = cb
 	return nil
 }
 
-func traceCallback(ctx context.Context, mod api.Module, evt TraceEvent, pDB, pArg1, pArg2 uint32) (rc uint32) {
-	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.trace != nil {
+func (e *env) Xgo_trace(evt, pDB, pArg1, pArg2 int32) int32 {
+	if c, ok := e.DB.(*Conn); ok && c.handle == ptr_t(pDB) && c.trace != nil {
 		var arg1, arg2 any
-		if evt == TRACE_CLOSE {
+		if TraceEvent(evt) == TRACE_CLOSE {
 			arg1 = c
 		} else {
 			for _, s := range c.stmts {
-				if pArg1 == s.handle {
+				if ptr_t(pArg1) == s.handle {
 					arg1 = s
-					switch evt {
+					switch TraceEvent(evt) {
 					case TRACE_STMT:
 						arg2 = s.SQL()
 					case TRACE_PROFILE:
-						arg2 = int64(util.ReadUint64(mod, pArg2))
+						arg2 = int64(e.Read64(ptr_t(pArg2)))
 					}
 					break
 				}
 			}
 		}
 		if arg1 != nil {
-			_, rc = errorCode(c.trace(evt, arg1, arg2), ERROR)
+			_ = c.trace(TraceEvent(evt), arg1, arg2)
 		}
 	}
-	return rc
+	return _OK
 }
 
-// WalCheckpoint checkpoints a WAL database.
+// 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)
+func (c *Conn) WALCheckpoint(schema string, mode CheckpointMode) (nLog, nCkpt int, err error) {
+	if c.interrupt.Err() != nil {
+		return 0, 0, INTERRUPT
+	}
+
+	defer c.arena.Mark()()
+	nLogPtr := c.arena.New(ptrlen)
+	nCkptPtr := c.arena.New(ptrlen)
+	schemaPtr := c.arena.String(schema)
+	rc := res_t(c.wrp.Xsqlite3_wal_checkpoint_v2(
+		int32(c.handle), int32(schemaPtr), int32(mode),
+		int32(nLogPtr), int32(nCkptPtr)))
+	nLog = int(int32(c.wrp.Read32(nLogPtr)))
+	nCkpt = int(int32(c.wrp.Read32(nCkptPtr)))
+	return nLog, nCkpt, c.error(rc)
 }
 
-// WalAutoCheckpoint configures WAL auto-checkpoints.
+// 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)
+func (c *Conn) WALAutoCheckpoint(pages int) error {
+	rc := res_t(c.wrp.Xsqlite3_wal_autocheckpoint(int32(c.handle), int32(pages)))
+	return c.error(rc)
 }
 
-// WalHook registers a callback function to be invoked
+// 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
+func (c *Conn) WALHook(cb func(db *Conn, schema string, pages int) error) {
+	var enable int32
 	if cb != nil {
 		enable = 1
 	}
-	c.call("sqlite3_wal_hook_go", uint64(c.handle), enable)
+	c.wrp.Xsqlite3_wal_hook_go(int32(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)
+func (e *env) Xgo_wal_hook(_, pDB, zSchema, pages int32) int32 {
+	if c, ok := e.DB.(*Conn); ok && c.handle == ptr_t(pDB) && c.wal != nil {
+		schema := e.ReadString(ptr_t(zSchema), _MAX_NAME)
 		err := c.wal(c, schema, int(pages))
-		_, rc = errorCode(err, ERROR)
+		_, rc := errorCode(err, ERROR)
+		return int32(rc)
 	}
-	return rc
+	return _OK
 }
 
 // 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)
+	var funcPtr ptr_t
+	if cb != nil {
+		funcPtr = c.wrp.AddHandle(cb)
+	}
+	rc := res_t(c.wrp.Xsqlite3_autovacuum_pages_go(int32(c.handle), int32(funcPtr)))
+	return c.error(rc)
 }
 
-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)))
+func (e *env) Xgo_autovacuum_pages(pApp, zSchema, nDbPage, nFreePage, nBytePerPage int32) int32 {
+	fn := e.GetHandle(ptr_t(pApp)).(func(schema string, dbPages, freePages, bytesPerPage uint) uint)
+	schema := e.ReadString(ptr_t(zSchema), _MAX_NAME)
+	return int32(fn(schema, uint(uint32(nDbPage)), uint(uint32(nFreePage)), uint(uint32(nBytePerPage))))
 }
 
 // SoftHeapLimit imposes a soft limit on heap size.
 //
 // https://sqlite.org/c3ref/hard_heap_limit64.html
 func (c *Conn) SoftHeapLimit(n int64) int64 {
-	return int64(c.call("sqlite3_soft_heap_limit64", uint64(n)))
+	return c.wrp.Xsqlite3_soft_heap_limit64(n)
 }
 
-// SoftHeapLimit imposes a hard limit on heap size.
+// HardHeapLimit imposes a hard limit on heap size.
 //
 // https://sqlite.org/c3ref/hard_heap_limit64.html
 func (c *Conn) HardHeapLimit(n int64) int64 {
-	return int64(c.call("sqlite3_hard_heap_limit64", uint64(n)))
+	return c.wrp.Xsqlite3_hard_heap_limit64(n)
+}
+
+// EnableChecksums enables checksums on a database.
+//
+// https://sqlite.org/cksumvfs.html
+func (c *Conn) EnableChecksums(schema string) error {
+	r, err := c.FileControl(schema, FCNTL_RESERVE_BYTES)
+	if err != nil {
+		return err
+	}
+	if r == 8 {
+		// Correct value, enabled.
+		return nil
+	}
+	if r == 0 {
+		// Default value, enable.
+		_, err = c.FileControl(schema, FCNTL_RESERVE_BYTES, 8)
+		if err != nil {
+			return err
+		}
+		r, err = c.FileControl(schema, FCNTL_RESERVE_BYTES)
+		if err != nil {
+			return err
+		}
+	}
+	if r != 8 {
+		// Invalid value.
+		return errutil.ErrorString("sqlite3: reserve bytes must be 8, is: " + strconv.Itoa(r.(int)))
+	}
+
+	// VACUUM the database.
+	if schema != "" {
+		err = c.Exec(`VACUUM ` + QuoteIdentifier(schema))
+	} else {
+		err = c.Exec(`VACUUM`)
+	}
+	if err != nil {
+		return err
+	}
+
+	// Checkpoint the WAL.
+	_, _, err = c.WALCheckpoint(schema, CHECKPOINT_FULL)
+	return err
 }

conn.go

@@ -3,14 +3,17 @@ package sqlite3
 import (
 	"context"
 	"fmt"
+	"iter"
 	"math"
+	"math/rand"
 	"net/url"
+	"runtime"
 	"strings"
 	"time"
 
-	"github.com/ncruces/go-sqlite3/internal/util"
-	"github.com/ncruces/go-sqlite3/vfs"
-	"github.com/tetratelabs/wazero/api"
+	"github.com/hanzoai/sqlite3/internal/errutil"
+	"github.com/hanzoai/sqlite3/internal/sqlite3_wrap"
+	"github.com/hanzoai/sqlite3/vfs"
 )
 
 // Conn is a database connection handle.
@@ -18,13 +21,11 @@ import (
 //
 // https://sqlite.org/c3ref/sqlite3.html
 type Conn struct {
-	*sqlite
+	wrp *sqlite3_wrap.Wrapper
 
 	interrupt  context.Context
-	pending    *Stmt
 	stmts      []*Stmt
-	timer      *time.Timer
-	busy       func(int) bool
+	busy       func(context.Context, int) bool
 	log        func(xErrorCode, string)
 	collation  func(*Conn, string)
 	wal        func(*Conn, string, int) error
@@ -33,19 +34,29 @@ type Conn struct {
 	update     func(AuthorizerActionCode, string, string, int64)
 	commit     func() bool
 	rollback   func()
-	arena      arena
+	preupdate  func(PreUpdateData)
 
-	handle uint32
+	busy1st time.Time
+	busylst time.Time
+	arena   sqlite3_wrap.Arena
+	handle  ptr_t
+	gosched uint8
 }
 
-// Open calls [OpenFlags] with [OPEN_READWRITE], [OPEN_CREATE], [OPEN_URI] and [OPEN_NOFOLLOW].
+// Open calls [OpenFlags] with [OPEN_READWRITE], [OPEN_CREATE] and [OPEN_URI].
 func Open(filename string) (*Conn, error) {
-	return newConn(filename, OPEN_READWRITE|OPEN_CREATE|OPEN_URI|OPEN_NOFOLLOW)
+	return newConn(context.Background(), filename, OPEN_READWRITE|OPEN_CREATE|OPEN_URI)
+}
+
+// OpenContext is like [Open] but includes a context,
+// which is used to interrupt the process of opening the connection.
+func OpenContext(ctx context.Context, filename string) (*Conn, error) {
+	return newConn(ctx, filename, OPEN_READWRITE|OPEN_CREATE|OPEN_URI)
 }
 
 // OpenFlags opens an SQLite database file as specified by the filename argument.
 //
-// If none of the required flags is used, a combination of [OPEN_READWRITE] and [OPEN_CREATE] is used.
+// If none of the required flags are used, a combination of [OPEN_READWRITE] and [OPEN_CREATE] is used.
 // If a URI filename is used, PRAGMA statements to execute can be specified using "_pragma":
 //
 //	sqlite3.Open("file:demo.db?_pragma=busy_timeout(10000)")
@@ -55,25 +66,33 @@ func OpenFlags(filename string, flags OpenFlag) (*Conn, error) {
 	if flags&(OPEN_READONLY|OPEN_READWRITE|OPEN_CREATE) == 0 {
 		flags |= OPEN_READWRITE | OPEN_CREATE
 	}
-	return newConn(filename, flags)
+	return newConn(context.Background(), filename, flags)
 }
 
-type connKey struct{}
+func newConn(ctx context.Context, filename string, flags OpenFlag) (ret *Conn, _ error) {
+	err := ctx.Err()
+	if err != nil {
+		return nil, err
+	}
 
-func newConn(filename string, flags OpenFlag) (conn *Conn, err error) {
-	sqlite, err := instantiateSQLite()
+	c := &Conn{interrupt: ctx}
+	c.wrp, err = createWrapper(ctx)
 	if err != nil {
 		return nil, err
 	}
 	defer func() {
-		if conn == nil {
-			sqlite.close()
+		if ret == nil {
+			c.Close()
+		} else {
+			c.interrupt = context.Background()
 		}
 	}()
 
-	c := &Conn{sqlite: sqlite}
-	c.arena = c.newArena(1024)
-	c.ctx = context.WithValue(c.ctx, connKey{}, c)
+	c.wrp.DB = c
+	if logger := defaultLogger.Load(); logger != nil {
+		c.ConfigLog(*logger)
+	}
+	c.arena = c.wrp.NewArena()
 	c.handle, err = c.openDB(filename, flags)
 	if err == nil {
 		err = initExtensions(c)
@@ -84,24 +103,25 @@ func newConn(filename string, flags OpenFlag) (conn *Conn, err error) {
 	return c, nil
 }
 
-func (c *Conn) openDB(filename string, flags OpenFlag) (uint32, error) {
-	defer c.arena.mark()()
-	connPtr := c.arena.new(ptrlen)
-	namePtr := c.arena.string(filename)
+func (c *Conn) openDB(filename string, flags OpenFlag) (ptr_t, error) {
+	defer c.arena.Mark()()
+	connPtr := c.arena.New(ptrlen)
+	namePtr := c.arena.String(filename)
 
 	flags |= OPEN_EXRESCODE
-	r := c.call("sqlite3_open_v2", uint64(namePtr), uint64(connPtr), uint64(flags), 0)
+	rc := res_t(c.wrp.Xsqlite3_open_v2(int32(namePtr), int32(connPtr), int32(flags), 0))
 
-	handle := util.ReadUint32(c.mod, connPtr)
-	if err := c.sqlite.error(r, handle); err != nil {
+	handle := ptr_t(c.wrp.Read32(connPtr))
+	if err := c.errorFor(handle, rc); err != nil {
 		c.closeDB(handle)
 		return 0, err
 	}
 
+	c.wrp.Xsqlite3_progress_handler_go(int32(handle), 1000)
 	if flags|OPEN_URI != 0 && strings.HasPrefix(filename, "file:") {
 		var pragmas strings.Builder
-		if _, after, ok := strings.Cut(filename, "?"); ok {
-			query, _ := url.ParseQuery(after)
+		if u, err := url.Parse(filename); err == nil {
+			query := u.Query()
 			for _, p := range query["_pragma"] {
 				pragmas.WriteString(`PRAGMA `)
 				pragmas.WriteString(p)
@@ -109,22 +129,21 @@ func (c *Conn) openDB(filename string, flags OpenFlag) (uint32, 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 {
+			pragmaPtr := c.arena.String(pragmas.String())
+			rc := res_t(c.wrp.Xsqlite3_exec(int32(handle), int32(pragmaPtr), 0, 0, 0))
+			if err := c.errorFor(handle, rc, pragmas.String()); err != nil {
 				err = fmt.Errorf("sqlite3: invalid _pragma: %w", 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("sqlite3_close_v2", uint64(handle))
-	if err := c.sqlite.error(r, handle); err != nil {
+func (c *Conn) closeDB(handle ptr_t) {
+	rc := res_t(c.wrp.Xsqlite3_close_v2(int32(handle)))
+	if err := c.errorFor(handle, rc); err != nil {
 		panic(err)
 	}
 }
@@ -143,16 +162,13 @@ func (c *Conn) Close() error {
 		return nil
 	}
 
-	c.pending.Close()
-	c.pending = nil
-
-	r := c.call("sqlite3_close", uint64(c.handle))
-	if err := c.error(r); err != nil {
+	rc := res_t(c.wrp.Xsqlite3_close(int32(c.handle)))
+	if err := c.error(rc); err != nil {
 		return err
 	}
 
 	c.handle = 0
-	return c.close()
+	return c.wrp.Close()
 }
 
 // Exec is a convenience function that allows an application to run
@@ -160,12 +176,17 @@ func (c *Conn) Close() error {
 //
 // https://sqlite.org/c3ref/exec.html
 func (c *Conn) Exec(sql string) error {
-	c.checkInterrupt()
-	defer c.arena.mark()()
-	sqlPtr := c.arena.string(sql)
+	if c.interrupt.Err() != nil {
+		return INTERRUPT
+	}
+	return c.exec(sql)
+}
 
-	r := c.call("sqlite3_exec", uint64(c.handle), uint64(sqlPtr), 0, 0, 0)
-	return c.error(r, sql)
+func (c *Conn) exec(sql string) error {
+	defer c.arena.Mark()()
+	textPtr := c.arena.String(sql)
+	rc := res_t(c.wrp.Xsqlite3_exec(int32(c.handle), int32(textPtr), 0, 0, 0))
+	return c.error(rc, sql)
 }
 
 // Prepare calls [Conn.PrepareFlags] with no flags.
@@ -183,23 +204,26 @@ func (c *Conn) PrepareFlags(sql string, flags PrepareFlag) (stmt *Stmt, tail str
 	if len(sql) > _MAX_SQL_LENGTH {
 		return nil, "", TOOBIG
 	}
+	if c.interrupt.Err() != nil {
+		return nil, "", INTERRUPT
+	}
 
-	defer c.arena.mark()()
-	stmtPtr := c.arena.new(ptrlen)
-	tailPtr := c.arena.new(ptrlen)
-	sqlPtr := c.arena.string(sql)
+	defer c.arena.Mark()()
+	stmtPtr := c.arena.New(ptrlen)
+	tailPtr := c.arena.New(ptrlen)
+	textPtr := c.arena.String(sql)
 
-	r := c.call("sqlite3_prepare_v3", uint64(c.handle),
-		uint64(sqlPtr), uint64(len(sql)+1), uint64(flags),
-		uint64(stmtPtr), uint64(tailPtr))
+	rc := res_t(c.wrp.Xsqlite3_prepare_v3(int32(c.handle),
+		int32(textPtr), int32(len(sql)+1), int32(flags),
+		int32(stmtPtr), int32(tailPtr)))
 
-	stmt = &Stmt{c: c}
-	stmt.handle = util.ReadUint32(c.mod, stmtPtr)
-	if sql := sql[util.ReadUint32(c.mod, tailPtr)-sqlPtr:]; sql != "" {
+	stmt = &Stmt{c: c, sql: sql}
+	stmt.handle = ptr_t(c.wrp.Read32(stmtPtr))
+	if sql := sql[ptr_t(c.wrp.Read32(tailPtr))-textPtr:]; sql != "" {
 		tail = sql
 	}
 
-	if err := c.error(r, sql); err != nil {
+	if err := c.error(rc, sql); err != nil {
 		return nil, "", err
 	}
 	if stmt.handle == 0 {
@@ -213,47 +237,45 @@ func (c *Conn) PrepareFlags(sql string, flags PrepareFlag) (stmt *Stmt, tail str
 //
 // 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)
+	ptr := ptr_t(c.wrp.Xsqlite3_db_name(int32(c.handle), int32(n)))
 	if ptr == 0 {
 		return ""
 	}
-	return util.ReadString(c.mod, ptr, _MAX_NAME)
+	return c.wrp.ReadString(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
+	var ptr ptr_t
 	if schema != "" {
-		defer c.arena.mark()()
-		ptr = c.arena.string(schema)
+		defer c.arena.Mark()()
+		ptr = c.arena.String(schema)
 	}
-	r := c.call("sqlite3_db_filename", uint64(c.handle), uint64(ptr))
-	return vfs.GetFilename(c.ctx, c.mod, uint32(r), vfs.OPEN_MAIN_DB)
+	ptr = ptr_t(c.wrp.Xsqlite3_db_filename(int32(c.handle), int32(ptr)))
+	return vfs.GetFilename(c.wrp, ptr, 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
+func (c *Conn) ReadOnly(schema string) (ro, ok bool) {
+	var ptr ptr_t
 	if schema != "" {
-		defer c.arena.mark()()
-		ptr = c.arena.string(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
+	b := c.wrp.Xsqlite3_db_readonly(int32(c.handle), int32(ptr))
+	return b > 0, b < 0
 }
 
 // GetAutocommit tests the connection for auto-commit mode.
 //
 // https://sqlite.org/c3ref/get_autocommit.html
 func (c *Conn) GetAutocommit() bool {
-	r := c.call("sqlite3_get_autocommit", uint64(c.handle))
-	return r != 0
+	b := c.wrp.Xsqlite3_get_autocommit(int32(c.handle))
+	return b != 0
 }
 
 // LastInsertRowID returns the rowid of the most recent successful INSERT
@@ -261,8 +283,7 @@ func (c *Conn) GetAutocommit() bool {
 //
 // https://sqlite.org/c3ref/last_insert_rowid.html
 func (c *Conn) LastInsertRowID() int64 {
-	r := c.call("sqlite3_last_insert_rowid", uint64(c.handle))
-	return int64(r)
+	return c.wrp.Xsqlite3_last_insert_rowid(int32(c.handle))
 }
 
 // SetLastInsertRowID allows the application to set the value returned by
@@ -270,7 +291,7 @@ func (c *Conn) LastInsertRowID() int64 {
 //
 // 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))
+	c.wrp.Xsqlite3_set_last_insert_rowid(int32(c.handle), id)
 }
 
 // Changes returns the number of rows modified, inserted or deleted
@@ -279,8 +300,7 @@ func (c *Conn) SetLastInsertRowID(id int64) {
 //
 // https://sqlite.org/c3ref/changes.html
 func (c *Conn) Changes() int64 {
-	r := c.call("sqlite3_changes64", uint64(c.handle))
-	return int64(r)
+	return c.wrp.Xsqlite3_changes64(int32(c.handle))
 }
 
 // TotalChanges returns the number of rows modified, inserted or deleted
@@ -289,20 +309,18 @@ func (c *Conn) Changes() int64 {
 //
 // https://sqlite.org/c3ref/total_changes.html
 func (c *Conn) TotalChanges() int64 {
-	r := c.call("sqlite3_total_changes64", uint64(c.handle))
-	return int64(r)
+	return c.wrp.Xsqlite3_total_changes64(int32(c.handle))
 }
 
 // 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)
+	rc := res_t(c.wrp.Xsqlite3_db_release_memory(int32(c.handle)))
+	return c.error(rc)
 }
 
-// GetInterrupt gets the context set with [Conn.SetInterrupt],
-// or nil if none was set.
+// GetInterrupt gets the context set with [Conn.SetInterrupt].
 func (c *Conn) GetInterrupt() context.Context {
 	return c.interrupt
 }
@@ -322,44 +340,22 @@ func (c *Conn) GetInterrupt() context.Context {
 //
 // https://sqlite.org/c3ref/interrupt.html
 func (c *Conn) SetInterrupt(ctx context.Context) (old context.Context) {
-	// Is it the same context?
-	if ctx == c.interrupt {
-		return ctx
+	if ctx == nil {
+		panic("nil Context")
 	}
-
-	// A busy SQL statement prevents SQLite from ignoring an interrupt
-	// that comes before any other statements are started.
-	if c.pending == nil {
-		defer c.arena.mark()()
-		stmtPtr := c.arena.new(ptrlen)
-		loopPtr := c.arena.string(`WITH RECURSIVE c(x) AS (VALUES(0) UNION ALL SELECT x FROM c) SELECT x FROM c`)
-		c.call("sqlite3_prepare_v3", uint64(c.handle), uint64(loopPtr), math.MaxUint64, 0, uint64(stmtPtr), 0)
-		c.pending = &Stmt{c: c}
-		c.pending.handle = util.ReadUint32(c.mod, stmtPtr)
-	}
-
 	old = c.interrupt
 	c.interrupt = ctx
-
-	if old != nil && old.Done() != nil && (ctx == nil || ctx.Err() == nil) {
-		c.pending.Reset()
-	}
-	if ctx != nil && ctx.Done() != nil {
-		c.pending.Step()
-	}
 	return old
 }
 
-func (c *Conn) checkInterrupt() {
-	if c.interrupt != nil && c.interrupt.Err() != nil {
-		c.call("sqlite3_interrupt", uint64(c.handle))
-	}
-}
-
-func 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
+func (e *env) Xgo_progress_handler(_ int32) (interrupt int32) {
+	if c, ok := e.DB.(*Conn); ok {
+		if c.gosched++; c.gosched%16 == 0 {
+			runtime.Gosched()
+		}
+		if c.interrupt.Err() != nil {
+			interrupt = 1
+		}
 	}
 	return interrupt
 }
@@ -369,44 +365,25 @@ func progressCallback(ctx context.Context, mod api.Module, pDB uint32) (interrup
 // 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)
+	rc := res_t(c.wrp.Xsqlite3_busy_timeout(int32(c.handle), int32(ms)))
+	return c.error(rc)
 }
 
-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)
+func (e *env) Xgo_busy_timeout(count, tmout int32) (retry int32) {
+	// https://fractaledmind.github.io/2024/04/15/sqlite-on-rails-the-how-and-why-of-optimal-performance/
+	if c, ok := e.DB.(*Conn); ok && c.interrupt.Err() == nil {
+		switch {
+		case count == 0:
+			c.busy1st = time.Now()
+		case time.Since(c.busy1st) >= time.Duration(tmout)*time.Millisecond:
+			return 0
 		}
-
-		if delay = min(delay, tmout-prior); delay > 0 {
-			delay := time.Duration(delay) * time.Millisecond
-			if c.interrupt == nil || c.interrupt.Done() == nil {
-				time.Sleep(delay)
-				return 1
-			}
-			if c.timer == nil {
-				c.timer = time.NewTimer(delay)
-			} else {
-				c.timer.Reset(delay)
-			}
-			select {
-			case <-c.interrupt.Done():
-				c.timer.Stop()
-			case <-c.timer.C:
-				return 1
-			}
+		if time.Since(c.busylst) < time.Millisecond {
+			const sleepIncrement = 2*1024*1024 - 1 // power of two, ~2ms
+			time.Sleep(time.Duration(rand.Int63() & sleepIncrement))
 		}
+		c.busylst = time.Now()
+		return 1
 	}
 	return 0
 }
@@ -414,23 +391,23 @@ func timeoutCallback(ctx context.Context, mod api.Module, pDB uint32, count, tmo
 // 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
+func (c *Conn) BusyHandler(cb func(ctx context.Context, count int) (retry bool)) error {
+	var enable int32
 	if cb != nil {
 		enable = 1
 	}
-	r := c.call("sqlite3_busy_handler_go", uint64(c.handle), enable)
-	if err := c.error(r); err != nil {
+	rc := res_t(c.wrp.Xsqlite3_busy_handler_go(int32(c.handle), enable))
+	if err := c.error(rc); 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)) {
+func (e *env) Xgo_busy_handler(pDB, count int32) (retry int32) {
+	if c, ok := e.DB.(*Conn); ok && c.handle == ptr_t(pDB) && c.busy != nil {
+		if interrupt := c.interrupt; interrupt.Err() == nil &&
+			c.busy(interrupt, int(count)) {
 			retry = 1
 		}
 	}
@@ -440,21 +417,21 @@ func busyCallback(ctx context.Context, mod api.Module, pDB uint32, count int32)
 // Status retrieves runtime status information about a database connection.
 //
 // https://sqlite.org/c3ref/db_status.html
-func (c *Conn) Status(op DBStatus, reset bool) (current, highwater int, err error) {
-	defer c.arena.mark()()
-	hiPtr := c.arena.new(4)
-	curPtr := c.arena.new(4)
+func (c *Conn) Status(op DBStatus, reset bool) (current, highwater int64, err error) {
+	defer c.arena.Mark()()
+	hiPtr := c.arena.New(8)
+	curPtr := c.arena.New(8)
 
-	var i uint64
+	var i int32
 	if reset {
 		i = 1
 	}
 
-	r := c.call("sqlite3_db_status", uint64(c.handle),
-		uint64(op), uint64(curPtr), uint64(hiPtr), i)
-	if err = c.error(r); err == nil {
-		current = int(util.ReadUint32(c.mod, curPtr))
-		highwater = int(util.ReadUint32(c.mod, hiPtr))
+	rc := res_t(c.wrp.Xsqlite3_db_status64(int32(c.handle),
+		int32(op), int32(curPtr), int32(hiPtr), i))
+	if err = c.error(rc); err == nil {
+		current = int64(c.wrp.Read64(curPtr))
+		highwater = int64(c.wrp.Read64(hiPtr))
 	}
 	return
 }
@@ -463,51 +440,101 @@ func (c *Conn) Status(op DBStatus, reset bool) (current, highwater int, err erro
 //
 // https://sqlite.org/c3ref/table_column_metadata.html
 func (c *Conn) TableColumnMetadata(schema, table, column string) (declType, collSeq string, notNull, primaryKey, autoInc bool, err error) {
-	defer c.arena.mark()()
-
-	var schemaPtr, columnPtr uint32
-	declTypePtr := c.arena.new(ptrlen)
-	collSeqPtr := c.arena.new(ptrlen)
-	notNullPtr := c.arena.new(ptrlen)
-	primaryKeyPtr := c.arena.new(ptrlen)
-	autoIncPtr := c.arena.new(ptrlen)
-	if schema != "" {
-		schemaPtr = c.arena.string(schema)
-	}
-	tablePtr := c.arena.string(table)
+	defer c.arena.Mark()()
+	var (
+		declTypePtr   ptr_t
+		collSeqPtr    ptr_t
+		notNullPtr    ptr_t
+		primaryKeyPtr ptr_t
+		autoIncPtr    ptr_t
+		columnPtr     ptr_t
+		schemaPtr     ptr_t
+	)
 	if column != "" {
-		columnPtr = c.arena.string(column)
+		declTypePtr = c.arena.New(ptrlen)
+		collSeqPtr = c.arena.New(ptrlen)
+		notNullPtr = c.arena.New(ptrlen)
+		primaryKeyPtr = c.arena.New(ptrlen)
+		autoIncPtr = c.arena.New(ptrlen)
+		columnPtr = c.arena.String(column)
 	}
+	if schema != "" {
+		schemaPtr = c.arena.String(schema)
+	}
+	tablePtr := c.arena.String(table)
 
-	r := c.call("sqlite3_table_column_metadata", uint64(c.handle),
-		uint64(schemaPtr), uint64(tablePtr), uint64(columnPtr),
-		uint64(declTypePtr), uint64(collSeqPtr),
-		uint64(notNullPtr), uint64(primaryKeyPtr), uint64(autoIncPtr))
-	if err = c.error(r); err == nil && column != "" {
-		declType = util.ReadString(c.mod, util.ReadUint32(c.mod, declTypePtr), _MAX_NAME)
-		collSeq = util.ReadString(c.mod, util.ReadUint32(c.mod, collSeqPtr), _MAX_NAME)
-		notNull = util.ReadUint32(c.mod, notNullPtr) != 0
-		autoInc = util.ReadUint32(c.mod, autoIncPtr) != 0
-		primaryKey = util.ReadUint32(c.mod, primaryKeyPtr) != 0
+	rc := res_t(c.wrp.Xsqlite3_table_column_metadata(int32(c.handle),
+		int32(schemaPtr), int32(tablePtr), int32(columnPtr),
+		int32(declTypePtr), int32(collSeqPtr),
+		int32(notNullPtr), int32(primaryKeyPtr), int32(autoIncPtr)))
+	if err = c.error(rc); err == nil && column != "" {
+		if ptr := ptr_t(c.wrp.Read32(declTypePtr)); ptr != 0 {
+			declType = c.wrp.ReadString(ptr, _MAX_NAME)
+		}
+		if ptr := ptr_t(c.wrp.Read32(collSeqPtr)); ptr != 0 {
+			collSeq = c.wrp.ReadString(ptr, _MAX_NAME)
+		}
+		notNull = c.wrp.ReadBool(notNullPtr)
+		autoInc = c.wrp.ReadBool(autoIncPtr)
+		primaryKey = c.wrp.ReadBool(primaryKeyPtr)
 	}
 	return
 }
 
-func (c *Conn) error(rc uint64, sql ...string) error {
-	return c.sqlite.error(rc, c.handle, sql...)
+func (c *Conn) error(rc res_t, sql ...string) error {
+	return c.errorFor(c.handle, rc, sql...)
 }
 
-func (c *Conn) stmtsIter(yield func(*Stmt) bool) {
-	for _, s := range c.stmts {
-		if !yield(s) {
-			break
+func (c *Conn) errorFor(handle ptr_t, rc res_t, sql ...string) error {
+	if rc == _OK {
+		return nil
+	}
+
+	if ErrorCode(rc) == NOMEM || xErrorCode(rc) == IOERR_NOMEM {
+		panic(errutil.OOMErr)
+	}
+
+	var msg, query string
+	if handle != 0 {
+		if ptr := ptr_t(c.wrp.Xsqlite3_errmsg(int32(handle))); ptr != 0 {
+			msg = c.wrp.ReadString(ptr, _MAX_LENGTH)
+			msg = strings.TrimPrefix(msg, "sqlite3: ")
+			msg = strings.TrimPrefix(msg, sqlite3_wrap.ErrorCodeString(rc)[len("sqlite3: "):])
+			msg = strings.TrimPrefix(msg, ": ")
+			if msg == "" || msg == "not an error" {
+				msg = ""
+			}
+		}
+
+		if len(sql) != 0 {
+			if i := c.wrp.Xsqlite3_error_offset(int32(handle)); i != -1 {
+				query = sql[0][i:]
+			}
+		}
+	}
+
+	var sys error
+	switch ErrorCode(rc) {
+	case CANTOPEN, IOERR:
+		sys = c.wrp.SysError
+	}
+
+	if sys != nil || msg != "" || query != "" {
+		return &Error{code: rc, sys: sys, msg: msg, sql: query}
+	}
+	return xErrorCode(rc)
+}
+
+// Stmts returns an iterator for the prepared statements
+// associated with the database connection.
+//
+// https://sqlite.org/c3ref/next_stmt.html
+func (c *Conn) Stmts() iter.Seq[*Stmt] {
+	return func(yield func(*Stmt) bool) {
+		for _, s := range c.stmts {
+			if !yield(s) {
+				break
+			}
 		}
 	}
 }
-
-// DriverConn is implemented by the SQLite [database/sql] driver connection.
-//
-// Deprecated: use [github.com/ncruces/go-sqlite3/driver.Conn] instead.
-type DriverConn interface {
-	Raw() *Conn
-}

conn_iter.go

@@ -1,11 +0,0 @@
-//go:build (go1.23 || goexperiment.rangefunc) && !vet
-
-package sqlite3
-
-import "iter"
-
-// Stmts returns an iterator for the prepared statements
-// associated with the database connection.
-//
-// https://sqlite.org/c3ref/next_stmt.html
-func (c *Conn) Stmts() iter.Seq[*Stmt] { return c.stmtsIter }

conn_old.go

@@ -1,9 +0,0 @@
-//go:build !(go1.23 || goexperiment.rangefunc) || vet
-
-package sqlite3
-
-// Stmts returns an iterator for the prepared statements
-// associated with the database connection.
-//
-// https://sqlite.org/c3ref/next_stmt.html
-func (c *Conn) Stmts() func(func(*Stmt) bool) { return c.stmtsIter }

const.go

@@ -1,18 +1,27 @@
 package sqlite3
 
-import "strconv"
+import (
+	"strconv"
+
+	"github.com/hanzoai/sqlite3/internal/sqlite3_wrap"
+)
 
 const (
 	_OK   = 0   /* Successful result */
 	_ROW  = 100 /* sqlite3_step() has another row ready */
 	_DONE = 101 /* sqlite3_step() has finished executing */
 
-	_MAX_NAME         = 1e6 // Self-imposed limit for most NUL terminated strings.
-	_MAX_LENGTH       = 1e9
-	_MAX_SQL_LENGTH   = 1e9
-	_MAX_FUNCTION_ARG = 100
+	_MAX_NAME       = 1e6 // Self-imposed limit for most NUL terminated strings.
+	_MAX_LENGTH     = 1e9
+	_MAX_SQL_LENGTH = 1e9
 
-	ptrlen = 4
+	ptrlen = sqlite3_wrap.PtrLen
+	intlen = sqlite3_wrap.IntLen
+)
+
+type (
+	ptr_t = sqlite3_wrap.Ptr_t
+	res_t = sqlite3_wrap.Res_t
 )
 
 // ErrorCode is a result code that [Error.Code] might return.
@@ -63,6 +72,9 @@ const (
 	ERROR_MISSING_COLLSEQ   ExtendedErrorCode = xErrorCode(ERROR) | (1 << 8)
 	ERROR_RETRY             ExtendedErrorCode = xErrorCode(ERROR) | (2 << 8)
 	ERROR_SNAPSHOT          ExtendedErrorCode = xErrorCode(ERROR) | (3 << 8)
+	ERROR_RESERVESIZE       ExtendedErrorCode = xErrorCode(ERROR) | (4 << 8)
+	ERROR_KEY               ExtendedErrorCode = xErrorCode(ERROR) | (5 << 8)
+	ERROR_UNABLE            ExtendedErrorCode = xErrorCode(ERROR) | (6 << 8)
 	IOERR_READ              ExtendedErrorCode = xErrorCode(IOERR) | (1 << 8)
 	IOERR_SHORT_READ        ExtendedErrorCode = xErrorCode(IOERR) | (2 << 8)
 	IOERR_WRITE             ExtendedErrorCode = xErrorCode(IOERR) | (3 << 8)
@@ -97,6 +109,8 @@ const (
 	IOERR_DATA              ExtendedErrorCode = xErrorCode(IOERR) | (32 << 8)
 	IOERR_CORRUPTFS         ExtendedErrorCode = xErrorCode(IOERR) | (33 << 8)
 	IOERR_IN_PAGE           ExtendedErrorCode = xErrorCode(IOERR) | (34 << 8)
+	IOERR_BADKEY            ExtendedErrorCode = xErrorCode(IOERR) | (35 << 8)
+	IOERR_CODEC             ExtendedErrorCode = xErrorCode(IOERR) | (36 << 8)
 	LOCKED_SHAREDCACHE      ExtendedErrorCode = xErrorCode(LOCKED) | (1 << 8)
 	LOCKED_VTAB             ExtendedErrorCode = xErrorCode(LOCKED) | (2 << 8)
 	BUSY_RECOVERY           ExtendedErrorCode = xErrorCode(BUSY) | (1 << 8)
@@ -158,13 +172,15 @@ const (
 
 // PrepareFlag is a flag that can be passed to [Conn.PrepareFlags].
 //
-// https://sqlite.org/c3ref/c_prepare_normalize.html
+// https://sqlite.org/c3ref/c_prepare_dont_log.html
 type PrepareFlag uint32
 
 const (
 	PREPARE_PERSISTENT PrepareFlag = 0x01
 	PREPARE_NORMALIZE  PrepareFlag = 0x02
 	PREPARE_NO_VTAB    PrepareFlag = 0x04
+	PREPARE_DONT_LOG   PrepareFlag = 0x10
+	PREPARE_FROM_DDL   PrepareFlag = 0x20
 )
 
 // FunctionFlag is a flag that can be passed to
@@ -174,11 +190,12 @@ const (
 type FunctionFlag uint32
 
 const (
-	DETERMINISTIC FunctionFlag = 0x000000800
-	DIRECTONLY    FunctionFlag = 0x000080000
-	INNOCUOUS     FunctionFlag = 0x000200000
-	// SUBTYPE        FunctionFlag = 0x000100000
-	// RESULT_SUBTYPE FunctionFlag = 0x001000000
+	DETERMINISTIC  FunctionFlag = 0x000000800
+	DIRECTONLY     FunctionFlag = 0x000080000
+	SUBTYPE        FunctionFlag = 0x000100000
+	INNOCUOUS      FunctionFlag = 0x000200000
+	RESULT_SUBTYPE FunctionFlag = 0x001000000
+	SELFORDER1     FunctionFlag = 0x002000000
 )
 
 // StmtStatus name counter values associated with the [Stmt.Status] method.
@@ -217,6 +234,8 @@ const (
 	DBSTATUS_DEFERRED_FKS        DBStatus = 10
 	DBSTATUS_CACHE_USED_SHARED   DBStatus = 11
 	DBSTATUS_CACHE_SPILL         DBStatus = 12
+	DBSTATUS_TEMPBUF_SPILL       DBStatus = 13
+	// DBSTATUS_MAX              DBStatus = 13
 )
 
 // DBConfig are the available database connection configuration options.
@@ -245,6 +264,11 @@ const (
 	DBCONFIG_TRUSTED_SCHEMA        DBConfig = 1017
 	DBCONFIG_STMT_SCANSTATUS       DBConfig = 1018
 	DBCONFIG_REVERSE_SCANORDER     DBConfig = 1019
+	DBCONFIG_ENABLE_ATTACH_CREATE  DBConfig = 1020
+	DBCONFIG_ENABLE_ATTACH_WRITE   DBConfig = 1021
+	DBCONFIG_ENABLE_COMMENTS       DBConfig = 1022
+	DBCONFIG_FP_DIGITS             DBConfig = 1023
+	// DBCONFIG_MAX                DBConfig = 1023
 )
 
 // FcntlOpcode are the available opcodes for [Conn.FileControl].
@@ -257,12 +281,14 @@ const (
 	FCNTL_CHUNK_SIZE          FcntlOpcode = 6
 	FCNTL_FILE_POINTER        FcntlOpcode = 7
 	FCNTL_PERSIST_WAL         FcntlOpcode = 10
+	FCNTL_VFSNAME             FcntlOpcode = 12
 	FCNTL_POWERSAFE_OVERWRITE FcntlOpcode = 13
 	FCNTL_VFS_POINTER         FcntlOpcode = 27
 	FCNTL_JOURNAL_POINTER     FcntlOpcode = 28
 	FCNTL_DATA_VERSION        FcntlOpcode = 35
 	FCNTL_RESERVE_BYTES       FcntlOpcode = 38
 	FCNTL_RESET_CACHE         FcntlOpcode = 42
+	FCNTL_NULL_IO             FcntlOpcode = 43
 )
 
 // LimitCategory are the available run-time limit categories.
@@ -283,6 +309,7 @@ const (
 	LIMIT_VARIABLE_NUMBER     LimitCategory = 9
 	LIMIT_TRIGGER_DEPTH       LimitCategory = 10
 	LIMIT_WORKER_THREADS      LimitCategory = 11
+	LIMIT_PARSER_DEPTH        LimitCategory = 12
 )
 
 // AuthorizerActionCode are the integer action codes
@@ -344,13 +371,14 @@ const (
 // CheckpointMode are all the checkpoint mode values.
 //
 // https://sqlite.org/c3ref/c_checkpoint_full.html
-type CheckpointMode uint32
+type CheckpointMode int32
 
 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 */
+	CHECKPOINT_NOOP     CheckpointMode = -1 /* Do no work at all */
+	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].

context.go

@@ -1,12 +1,10 @@
 package sqlite3
 
 import (
-	"encoding/json"
 	"errors"
-	"math"
 	"time"
 
-	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/hanzoai/sqlite3/internal/errutil"
 )
 
 // Context is the context in which an SQL function executes.
@@ -15,7 +13,7 @@ import (
 // https://sqlite.org/c3ref/context.html
 type Context struct {
 	c      *Conn
-	handle uint32
+	handle ptr_t
 }
 
 // Conn returns the database connection of the
@@ -31,16 +29,16 @@ 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("sqlite3_set_auxdata_go", uint64(ctx.handle), uint64(n), uint64(ptr))
+	ptr := ctx.c.wrp.AddHandle(data)
+	ctx.c.wrp.Xsqlite3_set_auxdata_go(int32(ctx.handle), int32(n), int32(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("sqlite3_get_auxdata", uint64(ctx.handle), uint64(n)))
-	return util.GetHandle(ctx.c.ctx, ptr)
+	ptr := ptr_t(ctx.c.wrp.Xsqlite3_get_auxdata(int32(ctx.handle), int32(n)))
+	return ctx.c.wrp.GetHandle(ptr)
 }
 
 // ResultBool sets the result of the function to a bool.
@@ -67,60 +65,61 @@ func (ctx Context) ResultInt(value int) {
 //
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultInt64(value int64) {
-	ctx.c.call("sqlite3_result_int64",
-		uint64(ctx.handle), uint64(value))
+	ctx.c.wrp.Xsqlite3_result_int64(
+		int32(ctx.handle), value)
 }
 
 // ResultFloat sets the result of the function to a float64.
 //
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultFloat(value float64) {
-	ctx.c.call("sqlite3_result_double",
-		uint64(ctx.handle), math.Float64bits(value))
+	ctx.c.wrp.Xsqlite3_result_double(
+		int32(ctx.handle), value)
 }
 
 // ResultText sets the result of the function to a string.
 //
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultText(value string) {
-	ptr := ctx.c.newString(value)
-	ctx.c.call("sqlite3_result_text_go",
-		uint64(ctx.handle), uint64(ptr), uint64(len(value)))
+	ptr := ctx.c.wrp.NewString(value)
+	ctx.c.wrp.Xsqlite3_result_text_go(
+		int32(ctx.handle), int32(ptr), int64(len(value)))
 }
 
 // ResultRawText sets the text result of the function to a []byte.
 //
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultRawText(value []byte) {
-	ptr := ctx.c.newBytes(value)
-	ctx.c.call("sqlite3_result_text_go",
-		uint64(ctx.handle), uint64(ptr), uint64(len(value)))
+	ctx.ResultText(string(value)) // does not escape
 }
 
 // ResultBlob sets the result of the function to a []byte.
-// Returning a nil slice is the same as calling [Context.ResultNull].
 //
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultBlob(value []byte) {
-	ptr := ctx.c.newBytes(value)
-	ctx.c.call("sqlite3_result_blob_go",
-		uint64(ctx.handle), uint64(ptr), uint64(len(value)))
+	if len(value) == 0 {
+		ctx.ResultZeroBlob(0)
+		return
+	}
+	ptr := ctx.c.wrp.NewBytes(value)
+	ctx.c.wrp.Xsqlite3_result_blob_go(
+		int32(ctx.handle), int32(ptr), int64(len(value)))
 }
 
 // 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("sqlite3_result_zeroblob64",
-		uint64(ctx.handle), uint64(n))
+	ctx.c.wrp.Xsqlite3_result_zeroblob64(
+		int32(ctx.handle), n)
 }
 
 // ResultNull sets the result of the function to NULL.
 //
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultNull() {
-	ctx.c.call("sqlite3_result_null",
-		uint64(ctx.handle))
+	ctx.c.wrp.Xsqlite3_result_null(
+		int32(ctx.handle))
 }
 
 // ResultTime sets the result of the function to a [time.Time].
@@ -140,19 +139,19 @@ func (ctx Context) ResultTime(value time.Time, format TimeFormat) {
 	case float64:
 		ctx.ResultFloat(v)
 	default:
-		panic(util.AssertErr())
+		panic(errutil.AssertErr())
 	}
 }
 
 func (ctx Context) resultRFC3339Nano(value time.Time) {
-	const maxlen = uint64(len(time.RFC3339Nano)) + 5
-
-	ptr := ctx.c.new(maxlen)
-	buf := util.View(ctx.c.mod, ptr, maxlen)
+	const maxlen = 48
+	ptr := ctx.c.wrp.New(maxlen)
+	buf := ctx.c.wrp.Bytes(ptr, maxlen)
 	buf = value.AppendFormat(buf[:0], time.RFC3339Nano)
+	_ = append(buf, 0)
 
-	ctx.c.call("sqlite3_result_text_go",
-		uint64(ctx.handle), uint64(ptr), uint64(len(buf)))
+	ctx.c.wrp.Xsqlite3_result_text_go(
+		int32(ctx.handle), int32(ptr), int64(len(buf)))
 }
 
 // ResultPointer sets the result of the function to NULL, just like [Context.ResultNull],
@@ -161,21 +160,9 @@ 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("sqlite3_result_pointer_go",
-		uint64(ctx.handle), uint64(valPtr))
-}
-
-// ResultJSON sets the result of the function to the JSON encoding of value.
-//
-// https://sqlite.org/c3ref/result_blob.html
-func (ctx Context) ResultJSON(value any) {
-	data, err := json.Marshal(value)
-	if err != nil {
-		ctx.ResultError(err)
-		return // notest
-	}
-	ctx.ResultRawText(data)
+	valPtr := ctx.c.wrp.AddHandle(ptr)
+	ctx.c.wrp.Xsqlite3_result_pointer_go(
+		int32(ctx.handle), int32(valPtr))
 }
 
 // ResultValue sets the result of the function to a copy of [Value].
@@ -186,8 +173,8 @@ func (ctx Context) ResultValue(value Value) {
 		ctx.ResultError(MISUSE)
 		return
 	}
-	ctx.c.call("sqlite3_result_value",
-		uint64(ctx.handle), uint64(value.handle))
+	ctx.c.wrp.Xsqlite3_result_value(
+		int32(ctx.handle), int32(value.handle))
 }
 
 // ResultError sets the result of the function an error.
@@ -195,33 +182,41 @@ 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("sqlite3_result_error_nomem", uint64(ctx.handle))
+		ctx.c.wrp.Xsqlite3_result_error_nomem(int32(ctx.handle))
 		return
 	}
 
 	if errors.Is(err, TOOBIG) {
-		ctx.c.call("sqlite3_result_error_toobig", uint64(ctx.handle))
+		ctx.c.wrp.Xsqlite3_result_error_toobig(int32(ctx.handle))
 		return
 	}
 
-	msg, code := errorCode(err, _OK)
+	msg, code := errorCode(err, ERROR)
 	if msg != "" {
-		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)))
+		defer ctx.c.arena.Mark()()
+		ptr := ctx.c.arena.String(msg)
+		ctx.c.wrp.Xsqlite3_result_error(
+			int32(ctx.handle), int32(ptr), int32(len(msg)))
 	}
-	if code != _OK {
-		ctx.c.call("sqlite3_result_error_code",
-			uint64(ctx.handle), uint64(code))
+	if code != res_t(ERROR) {
+		ctx.c.wrp.Xsqlite3_result_error_code(
+			int32(ctx.handle), int32(code))
 	}
 }
 
+// ResultSubtype sets the subtype of the result of the function.
+//
+// https://sqlite.org/c3ref/result_subtype.html
+func (ctx Context) ResultSubtype(t uint) {
+	ctx.c.wrp.Xsqlite3_result_subtype(
+		int32(ctx.handle), int32(t))
+}
+
 // 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
+	b := ctx.c.wrp.Xsqlite3_vtab_nochange(int32(ctx.handle))
+	return b != 0
 }

driver/driver.go

@@ -1,10 +1,8 @@
 // Package driver provides a database/sql driver for SQLite.
 //
 // Importing package driver registers a [database/sql] driver named "sqlite3".
-// You may also need to import package embed.
 //
-//	import _ "github.com/ncruces/go-sqlite3/driver"
-//	import _ "github.com/ncruces/go-sqlite3/embed"
+//	import _ "github.com/hanzoai/sqlite3/driver"
 //
 // The data source name for "sqlite3" databases can be a filename or a "file:" [URI].
 //
@@ -20,35 +18,58 @@
 //   - a [serializable] transaction is always "immediate";
 //   - a [read-only] transaction is always "deferred".
 //
+// # Datatypes In SQLite
+//
+// SQLite is dynamically typed.
+// Columns can mostly hold any value regardless of their declared type.
+// SQLite supports most [driver.Value] types out of the box,
+// but bool and [time.Time] require special care.
+//
+// Booleans can be stored on any column type and scanned back to a *bool.
+// However, if scanned to a *any, booleans may either become an
+// int64, string or bool, depending on the declared type of the column.
+// If you use BOOLEAN for your column type,
+// 1 and 0 will always scan as true and false.
+//
 // # Working with time
 //
+// Time values can similarly be stored on any column type.
 // The time encoding/decoding format can be specified using "_timefmt":
 //
 //	sql.Open("sqlite3", "file:demo.db?_timefmt=sqlite")
 //
-// Possible values are: "auto" (the default), "sqlite", "rfc3339";
+// Special values are: "auto" (the default), "sqlite", "rfc3339";
 //   - "auto" encodes as RFC 3339 and decodes any [format] supported by SQLite;
 //   - "sqlite" encodes as SQLite and decodes any [format] supported by SQLite;
 //   - "rfc3339" encodes and decodes RFC 3339 only.
 //
-// If you encode as RFC 3339 (the default),
-// consider using the TIME [collating sequence] to produce a time-ordered sequence.
+// You can also set "_timefmt" to an arbitrary [sqlite3.TimeFormat] or [time.Layout].
 //
-// To scan values in other formats, [sqlite3.TimeFormat.Scanner] may be helpful.
-// To bind values in other formats, [sqlite3.TimeFormat.Encode] them before binding.
+// If you encode as RFC 3339 (the default),
+// consider using the TIME [collating sequence] to produce time-ordered sequences.
+//
+// If you encode as RFC 3339 (the default),
+// time values will scan back to a *time.Time unless your column type is TEXT.
+// Otherwise, if scanned to a *any, time values may either become an
+// int64, float64 or string, depending on the time format and declared type of the column.
+// If you use DATE, TIME, DATETIME, or TIMESTAMP for your column type,
+// "_timefmt" will be used to decode values.
+//
+// To scan values in custom formats, [sqlite3.TimeFormat.Scanner] may be helpful.
+// To bind values in custom formats, [sqlite3.TimeFormat.Encode] them before binding.
 //
 // When using a custom time struct, you'll have to implement
 // [database/sql/driver.Valuer] and [database/sql.Scanner].
 //
-// The Value method should ideally serialise to a time [format] supported by SQLite.
+// The Value method should ideally encode to a time [format] supported by SQLite.
 // This ensures SQL date and time functions work as they should,
 // and that your schema works with other SQLite tools.
 // [sqlite3.TimeFormat.Encode] may help.
 //
 // The Scan method needs to take into account that the value it receives can be of differing types.
 // It can already be a [time.Time], if the driver decoded the value according to "_timefmt" rules.
-// Or it can be a: string, int64, float64, []byte, nil,
-// depending on the column type and what whoever wrote the value.
+// Or it can be a: string, int64, float64, []byte, or nil,
+// depending on the column type and whoever wrote the value.
 // [sqlite3.TimeFormat.Decode] may help.
 //
 // # Setting PRAGMAs
@@ -81,17 +102,19 @@ import (
 	"fmt"
 	"io"
 	"net/url"
+	"reflect"
 	"strings"
 	"time"
 	"unsafe"
 
-	"github.com/ncruces/go-sqlite3"
-	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/internal/errutil"
+	"github.com/hanzoai/sqlite3/internal/util"
 )
 
 // This variable can be replaced with -ldflags:
 //
-//	go build -ldflags="-X github.com/ncruces/go-sqlite3/driver.driverName=sqlite"
+//	go build -ldflags="-X github.com/hanzoai/sqlite3/driver.driverName=sqlite"
 var driverName = "sqlite3"
 
 func init() {
@@ -107,17 +130,17 @@ func init() {
 // The second callback is called before the driver closes a connection.
 // The [sqlite3.Conn] can be used to execute queries, register functions, etc.
 func Open(dataSourceName string, fn ...func(*sqlite3.Conn) error) (*sql.DB, error) {
-	var drv SQLite
 	if len(fn) > 2 {
 		return nil, sqlite3.MISUSE
 	}
+	var init, term func(*sqlite3.Conn) error
 	if len(fn) > 1 {
-		drv.term = fn[1]
+		term = fn[1]
 	}
 	if len(fn) > 0 {
-		drv.init = fn[0]
+		init = fn[0]
 	}
-	c, err := drv.OpenConnector(dataSourceName)
+	c, err := newConnector(dataSourceName, init, term)
 	if err != nil {
 		return nil, err
 	}
@@ -125,10 +148,7 @@ func Open(dataSourceName string, fn ...func(*sqlite3.Conn) error) (*sql.DB, erro
 }
 
 // SQLite implements [database/sql/driver.Driver].
-type SQLite struct {
-	init func(*sqlite3.Conn) error
-	term func(*sqlite3.Conn) error
-}
+type SQLite struct{}
 
 var (
 	// Ensure these interfaces are implemented:
@@ -137,7 +157,7 @@ var (
 
 // Open implements [database/sql/driver.Driver].
 func (d *SQLite) Open(name string) (driver.Conn, error) {
-	c, err := d.newConnector(name)
+	c, err := newConnector(name, nil, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -146,23 +166,25 @@ func (d *SQLite) Open(name string) (driver.Conn, error) {
 
 // OpenConnector implements [database/sql/driver.DriverContext].
 func (d *SQLite) OpenConnector(name string) (driver.Connector, error) {
-	return d.newConnector(name)
+	return newConnector(name, nil, nil)
 }
 
-func (d *SQLite) newConnector(name string) (*connector, error) {
-	c := connector{driver: d, name: name}
+func newConnector(name string, init, term func(*sqlite3.Conn) error) (*connector, error) {
+	c := connector{name: name, init: init, term: term}
 
 	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
-			}
-			txlock = query.Get("_txlock")
-			timefmt = query.Get("_timefmt")
-			c.pragmas = query.Has("_pragma")
+		u, err := url.Parse(name)
+		if err != nil {
+			return nil, err
 		}
+		query, err := url.ParseQuery(u.RawQuery)
+		if err != nil {
+			return nil, err
+		}
+		txlock = query.Get("_txlock")
+		timefmt = query.Get("_timefmt")
+		c.pragmas = query.Has("_pragma")
 	}
 
 	switch txlock {
@@ -190,7 +212,8 @@ func (d *SQLite) newConnector(name string) (*connector, error) {
 }
 
 type connector struct {
-	driver  *SQLite
+	init    func(*sqlite3.Conn) error
+	term    func(*sqlite3.Conn) error
 	name    string
 	txLock  string
 	tmRead  sqlite3.TimeFormat
@@ -199,28 +222,29 @@ type connector struct {
 }
 
 func (n *connector) Driver() driver.Driver {
-	return n.driver
+	return &SQLite{}
 }
 
-func (n *connector) Connect(ctx context.Context) (_ driver.Conn, err error) {
+func (n *connector) Connect(ctx context.Context) (ret driver.Conn, err error) {
 	c := &conn{
 		txLock:  n.txLock,
 		tmRead:  n.tmRead,
 		tmWrite: n.tmWrite,
 	}
 
-	c.Conn, err = sqlite3.Open(n.name)
+	c.Conn, err = sqlite3.OpenContext(ctx, n.name)
 	if err != nil {
 		return nil, err
 	}
 	defer func() {
-		if err != nil {
+		if ret == nil {
 			c.Close()
 		}
 	}()
 
-	old := c.Conn.SetInterrupt(ctx)
-	defer c.Conn.SetInterrupt(old)
+	if old := c.Conn.SetInterrupt(ctx); old != ctx {
+		defer c.Conn.SetInterrupt(old)
+	}
 
 	if !n.pragmas {
 		err = c.Conn.BusyTimeout(time.Minute)
@@ -228,30 +252,29 @@ func (n *connector) Connect(ctx context.Context) (_ driver.Conn, err error) {
 			return nil, err
 		}
 	}
-	if n.driver.init != nil {
-		err = n.driver.init(c.Conn)
+	if n.init != nil {
+		err = n.init(c.Conn)
 		if err != nil {
 			return nil, err
 		}
 	}
-	if n.pragmas || n.driver.init != nil {
+	if n.pragmas || n.init != nil {
 		s, _, err := c.Conn.Prepare(`PRAGMA query_only`)
 		if err != nil {
 			return nil, err
 		}
-		if s.Step() && s.ColumnBool(0) {
-			c.readOnly = '1'
-		} else {
-			c.readOnly = '0'
+		defer s.Close()
+		if s.Step() {
+			c.readOnly = s.ColumnBool(0)
 		}
 		err = s.Close()
 		if err != nil {
 			return nil, err
 		}
 	}
-	if n.driver.term != nil {
+	if n.term != nil {
 		err = c.Conn.Trace(sqlite3.TRACE_CLOSE, func(sqlite3.TraceEvent, any, any) error {
-			return n.driver.term(c.Conn)
+			return n.term(c.Conn)
 		})
 		if err != nil {
 			return nil, err
@@ -274,6 +297,7 @@ func (n *connector) Connect(ctx context.Context) (_ driver.Conn, err error) {
 //	if err != nil {
 //		log.Fatal(err)
 //	}
+//	defer conn.Close()
 //
 //	err = conn.Raw(func(driverConn any) error {
 //		conn := driverConn.(driver.Conn)
@@ -287,6 +311,8 @@ func (n *connector) Connect(ctx context.Context) (_ driver.Conn, err error) {
 type Conn interface {
 	Raw() *sqlite3.Conn
 	driver.Conn
+	driver.ConnBeginTx
+	driver.ConnPrepareContext
 }
 
 type conn struct {
@@ -295,15 +321,13 @@ type conn struct {
 	txReset  string
 	tmRead   sqlite3.TimeFormat
 	tmWrite  sqlite3.TimeFormat
-	readOnly byte
+	readOnly bool
 }
 
 var (
 	// Ensure these interfaces are implemented:
-	_ Conn                      = &conn{}
-	_ driver.ConnBeginTx        = &conn{}
-	_ driver.ConnPrepareContext = &conn{}
-	_ driver.ExecerContext      = &conn{}
+	_ Conn                 = &conn{}
+	_ driver.ExecerContext = &conn{}
 )
 
 func (c *conn) Raw() *sqlite3.Conn {
@@ -320,7 +344,7 @@ func (c *conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, e
 	var txLock string
 	switch opts.Isolation {
 	default:
-		return nil, util.IsolationErr
+		return nil, errutil.IsolationErr
 	case driver.IsolationLevel(sql.LevelLinearizable):
 		txLock = "exclusive"
 	case driver.IsolationLevel(sql.LevelSerializable):
@@ -333,13 +357,14 @@ func (c *conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, e
 
 	c.txReset = ``
 	txBegin := `BEGIN ` + txLock
-	if opts.ReadOnly {
+	if opts.ReadOnly && !c.readOnly {
 		txBegin += ` ; PRAGMA query_only=on`
-		c.txReset = `; PRAGMA query_only=` + string(c.readOnly)
+		c.txReset = `; PRAGMA query_only=off`
 	}
 
-	old := c.Conn.SetInterrupt(ctx)
-	defer c.Conn.SetInterrupt(old)
+	if old := c.Conn.SetInterrupt(ctx); old != ctx {
+		defer c.Conn.SetInterrupt(old)
+	}
 
 	err := c.Conn.Exec(txBegin)
 	if err != nil {
@@ -357,13 +382,12 @@ func (c *conn) Commit() error {
 }
 
 func (c *conn) Rollback() error {
-	err := c.Conn.Exec(`ROLLBACK` + c.txReset)
-	if errors.Is(err, sqlite3.INTERRUPT) {
-		old := c.Conn.SetInterrupt(context.Background())
+	// ROLLBACK even if interrupted.
+	ctx := context.Background()
+	if old := c.Conn.SetInterrupt(ctx); old != ctx {
 		defer c.Conn.SetInterrupt(old)
-		err = c.Conn.Exec(`ROLLBACK` + c.txReset)
 	}
-	return err
+	return c.Conn.Exec(`ROLLBACK` + c.txReset)
 }
 
 func (c *conn) Prepare(query string) (driver.Stmt, error) {
@@ -372,16 +396,17 @@ func (c *conn) Prepare(query string) (driver.Stmt, error) {
 }
 
 func (c *conn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) {
-	old := c.Conn.SetInterrupt(ctx)
-	defer c.Conn.SetInterrupt(old)
+	if old := c.Conn.SetInterrupt(ctx); old != ctx {
+		defer c.Conn.SetInterrupt(old)
+	}
 
 	s, tail, err := c.Conn.Prepare(query)
 	if err != nil {
 		return nil, err
 	}
-	if tail != "" {
+	if notWhitespace(tail) {
 		s.Close()
-		return nil, util.TailErr
+		return nil, errutil.TailErr
 	}
 	return &stmt{Stmt: s, tmRead: c.tmRead, tmWrite: c.tmWrite, inputs: -2}, nil
 }
@@ -398,8 +423,9 @@ func (c *conn) ExecContext(ctx context.Context, query string, args []driver.Name
 		return resultRowsAffected(0), nil
 	}
 
-	old := c.Conn.SetInterrupt(ctx)
-	defer c.Conn.SetInterrupt(old)
+	if old := c.Conn.SetInterrupt(ctx); old != ctx {
+		defer c.Conn.SetInterrupt(old)
+	}
 
 	err := c.Conn.Exec(query)
 	if err != nil {
@@ -462,15 +488,19 @@ func (s *stmt) ExecContext(ctx context.Context, args []driver.NamedValue) (drive
 		return nil, err
 	}
 
-	old := s.Stmt.Conn().SetInterrupt(ctx)
-	defer s.Stmt.Conn().SetInterrupt(old)
+	c := s.Stmt.Conn()
+	if old := c.SetInterrupt(ctx); old != ctx {
+		defer c.SetInterrupt(old)
+	}
 
-	err = s.Stmt.Exec()
+	err = errors.Join(
+		s.Stmt.Exec(),
+		s.Stmt.ClearBindings())
 	if err != nil {
 		return nil, err
 	}
 
-	return newResult(s.Stmt.Conn()), nil
+	return newResult(c), nil
 }
 
 func (s *stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
@@ -488,7 +518,7 @@ func (s *stmt) setupBindings(args []driver.NamedValue) (err error) {
 		if arg.Name == "" {
 			ids = append(ids, arg.Ordinal)
 		} else {
-			for _, prefix := range []string{":", "@", "$"} {
+			for _, prefix := range [...]string{":", "@", "$"} {
 				if id := s.Stmt.BindIndex(prefix + arg.Name); id != 0 {
 					ids = append(ids, id)
 				}
@@ -515,16 +545,16 @@ func (s *stmt) setupBindings(args []driver.NamedValue) (err error) {
 				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 util.Pointer:
+				err = s.Stmt.BindPointer(id, a.Value)
 			case nil:
 				err = s.Stmt.BindNull(id)
 			default:
-				panic(util.AssertErr())
+				panic(errutil.AssertErr())
+			}
+			if err != nil {
+				return err
 			}
-		}
-		if err != nil {
-			return err
 		}
 	}
 	return nil
@@ -534,7 +564,7 @@ func (s *stmt) CheckNamedValue(arg *driver.NamedValue) error {
 	switch arg.Value.(type) {
 	case bool, int, int64, float64, string, []byte,
 		time.Time, sqlite3.ZeroBlob,
-		util.JSON, util.PointerUnwrap,
+		util.JSON, util.Pointer,
 		nil:
 		return nil
 	default:
@@ -573,96 +603,243 @@ func (r resultRowsAffected) RowsAffected() (int64, error) {
 	return int64(r), nil
 }
 
+type scantype byte
+
+const (
+	_ANY scantype = iota
+	_INT
+	_REAL
+	_TEXT
+	_BLOB
+	_NULL
+	_BOOL
+	_TIME
+	_NOT_NULL
+)
+
+var (
+	_ [0]struct{} = [scantype(sqlite3.INTEGER) - _INT]struct{}{}
+	_ [0]struct{} = [scantype(sqlite3.FLOAT) - _REAL]struct{}{}
+	_ [0]struct{} = [scantype(sqlite3.TEXT) - _TEXT]struct{}{}
+	_ [0]struct{} = [scantype(sqlite3.BLOB) - _BLOB]struct{}{}
+	_ [0]struct{} = [scantype(sqlite3.NULL) - _NULL]struct{}{}
+	_ [0]struct{} = [_NOT_NULL & (_NOT_NULL - 1)]struct{}{}
+)
+
+func scanFromDecl(decl string) scantype {
+	// These types are only used before we have rows,
+	// and otherwise as type hints.
+	// The first few ensure STRICT tables are strictly typed.
+	// The other two are type hints for booleans and time.
+	switch decl {
+	case "INT", "INTEGER":
+		return _INT
+	case "REAL":
+		return _REAL
+	case "TEXT":
+		return _TEXT
+	case "BLOB":
+		return _BLOB
+	case "BOOLEAN":
+		return _BOOL
+	case "DATE", "TIME", "DATETIME", "TIMESTAMP":
+		return _TIME
+	}
+	return _ANY
+}
+
 type rows struct {
 	ctx context.Context
 	*stmt
 	names []string
 	types []string
+	scans []scantype
 }
 
+var (
+	// Ensure these interfaces are implemented:
+	_ driver.RowsColumnTypeDatabaseTypeName = &rows{}
+	_ driver.RowsColumnTypeNullable         = &rows{}
+)
+
 func (r *rows) Close() error {
-	r.Stmt.ClearBindings()
-	return r.Stmt.Reset()
+	return errors.Join(
+		r.Stmt.Reset(),
+		r.Stmt.ClearBindings())
 }
 
 func (r *rows) Columns() []string {
 	if r.names == nil {
 		count := r.Stmt.ColumnCount()
-		r.names = make([]string, count)
-		for i := range r.names {
-			r.names[i] = r.Stmt.ColumnName(i)
+		names := make([]string, count)
+		for i := range names {
+			names[i] = r.Stmt.ColumnName(i)
 		}
+		r.names = names
 	}
 	return r.names
 }
 
-func (r *rows) 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))
+func (r *rows) scanType(index int) scantype {
+	if r.scans == nil {
+		count := len(r.names)
+		scans := make([]scantype, count)
+		for i := range scans {
+			scans[i] = scanFromDecl(strings.ToUpper(r.Stmt.ColumnDeclType(i)))
 		}
+		r.scans = scans
+	}
+	return r.scans[index] &^ _NOT_NULL
+}
+
+func (r *rows) loadColumnMetadata() {
+	if r.types == nil {
+		c := r.Stmt.Conn()
+		count := len(r.names)
+		types := make([]string, count)
+		scans := make([]scantype, count)
+		for i := range types {
+			var declType string
+			var notNull, autoInc bool
+			if column := r.Stmt.ColumnOriginName(i); column != "" {
+				declType, _, notNull, _, autoInc, _ = c.TableColumnMetadata(
+					r.Stmt.ColumnDatabaseName(i),
+					r.Stmt.ColumnTableName(i),
+					column)
+			} else {
+				declType = r.Stmt.ColumnDeclType(i)
+			}
+			if declType != "" {
+				declType = strings.ToUpper(declType)
+				scans[i] = scanFromDecl(declType)
+				types[i] = declType
+			}
+			if notNull || autoInc {
+				scans[i] |= _NOT_NULL
+			}
+		}
+		r.types = types
+		r.scans = scans
 	}
-	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]
+	r.loadColumnMetadata()
+	decl := r.types[index]
+	if len := len(decl); len > 0 && decl[len-1] == ')' {
+		if i := strings.LastIndexByte(decl, '('); i >= 0 {
+			decl = decl[:i]
 		}
 	}
-	return strings.TrimSpace(decltype)
+	return strings.TrimSpace(decl)
+}
+
+func (r *rows) ColumnTypeNullable(index int) (nullable, ok bool) {
+	r.loadColumnMetadata()
+	nullable = r.scans[index]&^_NOT_NULL == 0
+	return nullable, !nullable
+}
+
+func (r *rows) ColumnTypeScanType(index int) (typ reflect.Type) {
+	r.loadColumnMetadata()
+	scan := r.scans[index] &^ _NOT_NULL
+
+	if r.Stmt.Busy() {
+		// SQLite is dynamically typed and we now have a row.
+		// Always use the type of the value itself,
+		// unless the scan type is more specific
+		// and can scan the actual value.
+		val := scantype(r.Stmt.ColumnType(index))
+		useValType := true
+		switch {
+		case scan == _TIME && val != _BLOB && val != _NULL:
+			t := r.Stmt.ColumnTime(index, r.tmRead)
+			useValType = t.IsZero()
+		case scan == _BOOL && val == _INT:
+			i := r.Stmt.ColumnInt64(index)
+			useValType = i != 0 && i != 1
+		case scan == _BLOB && val == _NULL:
+			useValType = false
+		}
+		if useValType {
+			scan = val
+		}
+	}
+
+	switch scan {
+	case _INT:
+		return reflect.TypeFor[int64]()
+	case _REAL:
+		return reflect.TypeFor[float64]()
+	case _TEXT:
+		return reflect.TypeFor[string]()
+	case _BLOB:
+		return reflect.TypeFor[[]byte]()
+	case _BOOL:
+		return reflect.TypeFor[bool]()
+	case _TIME:
+		return reflect.TypeFor[time.Time]()
+	default:
+		return reflect.TypeFor[any]()
+	}
+}
+
+func (r *rows) NextRow() error {
+	c := r.Stmt.Conn()
+	if old := c.SetInterrupt(r.ctx); old != r.ctx {
+		defer c.SetInterrupt(old)
+	}
+	if r.Stmt.Step() {
+		return nil
+	}
+	if err := r.Stmt.Err(); err != nil {
+		return err
+	}
+	return io.EOF
 }
 
 func (r *rows) Next(dest []driver.Value) error {
-	old := r.Stmt.Conn().SetInterrupt(r.ctx)
-	defer r.Stmt.Conn().SetInterrupt(old)
-
-	if !r.Stmt.Step() {
-		if err := r.Stmt.Err(); err != nil {
-			return err
-		}
-		return io.EOF
+	if err := r.NextRow(); err != nil {
+		return err
 	}
 
 	data := unsafe.Slice((*any)(unsafe.SliceData(dest)), len(dest))
-	err := r.Stmt.Columns(data)
-	for i := range dest {
-		if t, ok := r.decodeTime(i, dest[i]); ok {
-			dest[i] = t
-			continue
-		}
-		if s, ok := dest[i].(string); ok {
-			t, ok := maybeTime(s)
-			if ok {
-				dest[i] = t
-			}
-		}
+	if err := r.Stmt.ColumnsRaw(data...); err != nil {
+		return err
 	}
-	return err
+	for i := range dest {
+		dest[i] = r.convert(i, dest[i])
+	}
+	return nil
 }
 
-func (r *rows) decodeTime(i int, v any) (_ time.Time, ok bool) {
-	switch r.tmRead {
-	case sqlite3.TimeFormatDefault, time.RFC3339Nano:
-		// handled by maybeTime
-		return
+func (r *rows) convert(i int, val driver.Value) driver.Value {
+	scan := r.scanType(i)
+	if v, ok := val.([]byte); ok {
+		if len(v) == cap(v) { // a BLOB
+			return val
+		}
+		if scan != _TEXT {
+			t, ok := r.maybeTime(v)
+			if ok {
+				return t
+			}
+		}
+		val = string(v)
 	}
-	switch v.(type) {
-	case int64, float64, string:
-		// could be a time value
-	default:
-		return
+	switch scan {
+	case _TIME:
+		t, err := r.tmRead.Decode(val)
+		if err == nil {
+			return t
+		}
+	case _BOOL:
+		switch val {
+		case int64(0):
+			return false
+		case int64(1):
+			return true
+		}
 	}
-	switch r.declType(i) {
-	case "DATE", "TIME", "DATETIME", "TIMESTAMP":
-		// could be a time value
-	default:
-		return
-	}
-	t, err := r.tmRead.Decode(v)
-	return t, err == nil
+	return val
 }

driver/driver_127.go

@@ -0,0 +1,146 @@
+//go:build go1.27
+
+package driver
+
+import (
+	"database/sql"
+	"database/sql/driver"
+	"math"
+	"time"
+
+	"github.com/hanzoai/sqlite3"
+)
+
+func (r *rows) ScanColumn(ctx driver.ScanContext, i int, dest any) error {
+	typ := r.Stmt.ColumnType(i)
+
+	// Fast path.
+	var src any
+	switch typ {
+	case sqlite3.NULL:
+		// src = nil
+	case sqlite3.FLOAT:
+		f := r.stmt.ColumnFloat(i)
+		if r.scanFloat(f, dest) {
+			return nil
+		}
+		src = f
+	case sqlite3.INTEGER:
+		i := r.stmt.ColumnInt64(i)
+		if r.scanInt(i, dest) {
+			return nil
+		}
+		if r.scanFloat(float64(i), dest) {
+			return nil
+		}
+		src = i
+	default:
+		var b []byte
+		if typ == sqlite3.TEXT {
+			b = r.stmt.ColumnRawText(i)
+		} else {
+			b = r.stmt.ColumnRawBlob(i)
+		}
+		switch d := dest.(type) {
+		case *sql.RawBytes:
+			*d = b
+			return nil
+		case *string:
+			*d = string(b)
+			return nil
+		case *sql.NullString:
+			d.String = string(b)
+			d.Valid = true
+			return nil
+		case *[]byte:
+			*d = append((*d)[:0], b...)
+			return nil
+		}
+		src = b
+	}
+
+	// Time handling.
+	if typ != sqlite3.NULL && typ != sqlite3.BLOB {
+		var ok bool
+		switch d := dest.(type) {
+		case *time.Time:
+			*d, ok = r.scanTime(src)
+		case *sql.NullTime:
+			d.Time, ok = r.scanTime(src)
+			d.Valid = ok
+		}
+		if ok {
+			return nil
+		}
+	}
+
+	// Fallback.
+	return sql.ConvertAssign(ctx, dest, r.convert(i, src))
+}
+
+func (r *rows) scanTime(src any) (_ time.Time, _ bool) {
+	if s, ok := src.([]byte); ok {
+		if t, ok := r.maybeTime(s); ok {
+			return t, true
+		}
+		src = string(s)
+	}
+	t, err := r.tmRead.Decode(src)
+	return t, err == nil
+}
+
+func (r *rows) scanFloat(f float64, dest any) bool {
+	switch d := dest.(type) {
+	case *float64:
+		*d = f
+	case *float32:
+		*d = float32(f)
+	case *sql.NullFloat64:
+		d.Float64 = f
+		d.Valid = true
+	case *sql.Null[float32]:
+		d.V = float32(f)
+		d.Valid = true
+	default:
+		return false
+	}
+	return true
+}
+
+func (r *rows) scanInt(i int64, dest any) bool {
+	switch d := dest.(type) {
+	case *int64:
+		*d = i
+	case *sql.NullInt64:
+		d.Int64 = i
+		d.Valid = true
+
+	case *uint64:
+		*d = uint64(i)
+		return 0 <= i
+	case *sql.Null[uint64]:
+		d.V = uint64(i)
+		d.Valid = true
+		return 0 <= i
+
+	case *int:
+		*d = int(i)
+		return math.MinInt <= i && i <= math.MaxInt
+	case *sql.Null[int]:
+		d.V = int(i)
+		d.Valid = true
+		return math.MinInt <= i && i <= math.MaxInt
+
+	case *uint:
+		*d = uint(i)
+		return 0 <= i && uint64(i) <= math.MaxUint
+	case *sql.Null[uint]:
+		d.V = uint(i)
+		d.Valid = true
+		return 0 <= i && uint64(i) <= math.MaxUint
+
+	default:
+		return false
+	}
+	return true
+}

driver/driver_test.go

@@ -7,14 +7,16 @@ import (
 	"errors"
 	"math"
 	"net/url"
+	"reflect"
+	"runtime"
+	"strings"
 	"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/memdb"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/internal/errutil"
+	"github.com/hanzoai/sqlite3/internal/testcfg"
+	"github.com/hanzoai/sqlite3/vfs/memdb"
 )
 
 func Test_Open_error(t *testing.T) {
@@ -32,35 +34,40 @@ func Test_Open_error(t *testing.T) {
 func Test_Open_dir(t *testing.T) {
 	t.Parallel()
 
-	db, err := sql.Open("sqlite3", ".")
+	ctx := testcfg.Context(t)
+	db, err := Open(".")
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db.Close()
 
-	_, err = db.Conn(context.TODO())
+	_, err = db.Conn(ctx)
 	if err == nil {
 		t.Fatal("want error")
 	}
-	if !errors.Is(err, sqlite3.CANTOPEN) {
-		t.Errorf("got %v, want sqlite3.CANTOPEN", err)
+	if runtime.GOOS == "js" {
+		t.Skip("skipping on JS")
+	}
+	if !errors.Is(err, sqlite3.CANTOPEN_ISDIR) {
+		t.Errorf("got %v, want sqlite3.CANTOPEN_ISDIR", err)
 	}
 }
 
 func Test_Open_pragma(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t, url.Values{
+	dsn := memdb.TestDB(t, url.Values{
 		"_pragma": {"busy_timeout(1000)"},
 	})
 
-	db, err := sql.Open("sqlite3", tmp)
+	ctx := testcfg.Context(t)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db.Close()
 
 	var timeout int
-	err = db.QueryRow(`PRAGMA busy_timeout`).Scan(&timeout)
+	err = db.QueryRowContext(ctx, `PRAGMA busy_timeout`).Scan(&timeout)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -71,17 +78,18 @@ func Test_Open_pragma(t *testing.T) {
 
 func Test_Open_pragma_invalid(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t, url.Values{
+	dsn := memdb.TestDB(t, url.Values{
 		"_pragma": {"busy_timeout 1000"},
 	})
 
-	db, err := sql.Open("sqlite3", tmp)
+	ctx := testcfg.Context(t)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db.Close()
 
-	_, err = db.Conn(context.TODO())
+	_, err = db.Conn(ctx)
 	if err == nil {
 		t.Fatal("want error")
 	}
@@ -99,23 +107,24 @@ func Test_Open_pragma_invalid(t *testing.T) {
 
 func Test_Open_txLock(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t, url.Values{
+	dsn := memdb.TestDB(t, url.Values{
 		"_txlock": {"exclusive"},
 		"_pragma": {"busy_timeout(1000)"},
 	})
 
-	db, err := sql.Open("sqlite3", tmp)
+	ctx := testcfg.Context(t)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db.Close()
 
-	tx1, err := db.Begin()
+	tx1, err := db.BeginTx(ctx, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	_, err = db.Begin()
+	_, err = db.BeginTx(ctx, nil)
 	if err == nil {
 		t.Error("want error")
 	}
@@ -135,11 +144,11 @@ func Test_Open_txLock(t *testing.T) {
 
 func Test_Open_txLock_invalid(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t, url.Values{
+	dsn := memdb.TestDB(t, url.Values{
 		"_txlock": {"xclusive"},
 	})
 
-	_, err := sql.Open("sqlite3", tmp+"_txlock=xclusive")
+	_, err := Open(dsn)
 	if err == nil {
 		t.Fatal("want error")
 	}
@@ -150,22 +159,20 @@ func Test_Open_txLock_invalid(t *testing.T) {
 
 func Test_BeginTx(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t, url.Values{
+	dsn := memdb.TestDB(t, url.Values{
 		"_txlock": {"exclusive"},
 		"_pragma": {"busy_timeout(0)"},
 	})
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	db, err := sql.Open("sqlite3", tmp)
+	ctx := testcfg.Context(t)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db.Close()
 
 	_, err = db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted})
-	if err.Error() != string(util.IsolationErr) {
+	if err.Error() != string(errutil.IsolationErr) {
 		t.Error("want isolationErr")
 	}
 
@@ -198,18 +205,78 @@ func Test_BeginTx(t *testing.T) {
 	}
 }
 
+func Test_nested_context(t *testing.T) {
+	t.Parallel()
+	dsn := memdb.TestDB(t)
+
+	ctx := testcfg.Context(t)
+	db, err := Open(dsn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	tx, err := db.BeginTx(ctx, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer tx.Rollback()
+
+	outer, err := tx.Query(`SELECT value FROM generate_series(0)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer outer.Close()
+
+	want := func(rows *sql.Rows, want int) {
+		t.Helper()
+
+		var got int
+		rows.Next()
+		if err := rows.Scan(&got); err != nil {
+			t.Fatal(err)
+		}
+		if got != want {
+			t.Errorf("got %d, want %d", got, want)
+		}
+	}
+
+	want(outer, 0)
+
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	inner, err := tx.QueryContext(ctx, `SELECT value FROM generate_series(0)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer inner.Close()
+
+	want(inner, 0)
+	cancel()
+
+	var terr interface{ Temporary() bool }
+	if inner.Next() || !errors.Is(inner.Err(), context.Canceled) &&
+		(!errors.As(inner.Err(), &terr) || !terr.Temporary()) {
+		t.Fatalf("got %v, want cancellation", inner.Err())
+	}
+
+	want(outer, 1)
+}
+
 func Test_Prepare(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := sql.Open("sqlite3", tmp)
+	ctx := testcfg.Context(t)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db.Close()
 
 	var serr *sqlite3.Error
-	_, err = db.Prepare(`SELECT`)
+	_, err = db.PrepareContext(ctx, `SELECT`)
 	if err == nil {
 		t.Error("want error")
 	}
@@ -223,30 +290,28 @@ func Test_Prepare(t *testing.T) {
 		t.Error("got message:", got)
 	}
 
-	_, err = db.Prepare(`SELECT 1; `)
-	if err.Error() != string(util.TailErr) {
+	_, err = db.PrepareContext(ctx, `SELECT 1; `)
+	if err != nil {
+		t.Error(err)
+	}
+
+	_, err = db.PrepareContext(ctx, `SELECT 1; SELECT`)
+	if err.Error() != string(errutil.TailErr) {
 		t.Error("want tailErr")
 	}
 
-	_, err = db.Prepare(`SELECT 1; SELECT`)
-	if err.Error() != string(util.TailErr) {
-		t.Error("want tailErr")
-	}
-
-	_, err = db.Prepare(`SELECT 1; SELECT 2`)
-	if err.Error() != string(util.TailErr) {
+	_, err = db.PrepareContext(ctx, `SELECT 1; SELECT 2`)
+	if err.Error() != string(errutil.TailErr) {
 		t.Error("want tailErr")
 	}
 }
 
 func Test_QueryRow_named(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	db, err := sql.Open("sqlite3", tmp)
+	ctx := testcfg.Context(t)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -265,7 +330,7 @@ func Test_QueryRow_named(t *testing.T) {
 	defer stmt.Close()
 
 	date := time.Now()
-	row := stmt.QueryRow(true, sql.Named("AAA", math.Pi), nil /*3*/, nil /*4*/, date /*5*/)
+	row := stmt.QueryRowContext(ctx, true, sql.Named("AAA", math.Pi), nil /*3*/, nil /*4*/, date /*5*/)
 
 	var first bool
 	var fifth time.Time
@@ -294,15 +359,16 @@ func Test_QueryRow_named(t *testing.T) {
 
 func Test_QueryRow_blob_null(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := sql.Open("sqlite3", tmp)
+	ctx := testcfg.Context(t)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db.Close()
 
-	rows, err := db.Query(`
+	rows, err := db.QueryContext(ctx, `
 		SELECT NULL    UNION ALL
 		SELECT x'cafe' UNION ALL
 		SELECT x'babe' UNION ALL
@@ -331,11 +397,12 @@ func Test_time(t *testing.T) {
 
 	for _, fmt := range []string{"auto", "sqlite", "rfc3339", time.ANSIC} {
 		t.Run(fmt, func(t *testing.T) {
-			tmp := memdb.TestDB(t, url.Values{
+			dsn := memdb.TestDB(t, url.Values{
 				"_timefmt": {fmt},
 			})
 
-			db, err := sql.Open("sqlite3", tmp)
+			ctx := testcfg.Context(t)
+			db, err := Open(dsn)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -343,18 +410,18 @@ func Test_time(t *testing.T) {
 
 			twosday := time.Date(2022, 2, 22, 22, 22, 22, 0, time.UTC)
 
-			_, err = db.Exec(`CREATE TABLE test (at DATETIME)`)
+			_, err = db.ExecContext(ctx, `CREATE TABLE test (at DATETIME)`)
 			if err != nil {
 				t.Fatal(err)
 			}
 
-			_, err = db.Exec(`INSERT INTO test VALUES (?)`, twosday)
+			_, err = db.ExecContext(ctx, `INSERT INTO test VALUES (?)`, twosday)
 			if err != nil {
 				t.Fatal(err)
 			}
 
 			var got time.Time
-			err = db.QueryRow(`SELECT * FROM test`).Scan(&got)
+			err = db.QueryRowContext(ctx, `SELECT * FROM test`).Scan(&got)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -365,3 +432,167 @@ func Test_time(t *testing.T) {
 		})
 	}
 }
+
+func Test_ColumnType_ScanType(t *testing.T) {
+	var (
+		INT  = reflect.TypeFor[int64]()
+		REAL = reflect.TypeFor[float64]()
+		TEXT = reflect.TypeFor[string]()
+		BLOB = reflect.TypeFor[[]byte]()
+		BOOL = reflect.TypeFor[bool]()
+		TIME = reflect.TypeFor[time.Time]()
+		ANY  = reflect.TypeFor[any]()
+	)
+
+	t.Parallel()
+	dsn := memdb.TestDB(t)
+
+	ctx := testcfg.Context(t)
+	db, err := Open(dsn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	_, err = db.ExecContext(ctx, `
+		CREATE TABLE test (
+			col_int  INTEGER,
+			col_real REAL,
+			col_text TEXT,
+			col_blob BLOB,
+			col_bool BOOLEAN,
+			col_time DATETIME,
+			col_decimal DECIMAL
+		);
+		INSERT INTO test VALUES
+			(1, 1, 1, 1, 1, 1, 1),
+			(2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0),
+			('1', '1', '1', '1', '1', '1', '1'),
+			('x', 'x', 'x', 'x', 'x', 'x', 'x'),
+			(x'', x'', x'', x'', x'', x'', x''),
+			('2006-01-02T15:04:05Z', '2006-01-02T15:04:05Z', '2006-01-02T15:04:05Z', '2006-01-02T15:04:05Z',
+			 '2006-01-02T15:04:05Z', '2006-01-02T15:04:05Z', '2006-01-02T15:04:05Z'),
+			(TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE),
+			(NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	rows, err := db.QueryContext(ctx, `SELECT * FROM test`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer rows.Close()
+
+	cols, err := rows.ColumnTypes()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want := [][]reflect.Type{
+		{INT, REAL, TEXT, BLOB, BOOL, TIME, ANY},
+		{INT, REAL, TEXT, INT, BOOL, TIME, INT},
+		{INT, REAL, TEXT, REAL, INT, TIME, INT},
+		{INT, REAL, TEXT, TEXT, BOOL, TIME, INT},
+		{TEXT, TEXT, TEXT, TEXT, TEXT, TEXT, TEXT},
+		{BLOB, BLOB, BLOB, BLOB, BLOB, BLOB, BLOB},
+		{TEXT, TEXT, TEXT, TEXT, TEXT, TIME, TEXT},
+		{INT, REAL, TEXT, INT, BOOL, TIME, INT},
+		{ANY, ANY, ANY, BLOB, ANY, ANY, ANY},
+	}
+	for j, c := range cols {
+		got := c.ScanType()
+		if got != want[0][j] {
+			t.Errorf("want %v, got %v, at column %d", want[0][j], got, j)
+		}
+	}
+
+	dest := make([]any, len(cols))
+	for i := 1; rows.Next(); i++ {
+		cols, err := rows.ColumnTypes()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		for j, c := range cols {
+			got := c.ScanType()
+			if got != want[i][j] {
+				t.Errorf("want %v, got %v, at row %d column %d", want[i][j], got, i, j)
+			}
+			dest[j] = reflect.New(got).Interface()
+		}
+
+		err = rows.Scan(dest...)
+		if err != nil {
+			t.Error(err)
+		}
+	}
+
+	err = rows.Err()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func Test_rows_ScanColumn(t *testing.T) {
+	t.Parallel()
+	dsn := memdb.TestDB(t)
+
+	db, err := Open(dsn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	var tm time.Time
+	err = db.QueryRow(`SELECT NULL`).Scan(&tm)
+	if err == nil {
+		t.Error("want error")
+	}
+	// Go 1.27
+	err = db.QueryRow(`SELECT datetime()`).Scan(&tm)
+	if err != nil && !strings.HasPrefix(err.Error(), "sql: Scan error") {
+		t.Error(err)
+	}
+	if err == nil && tm.IsZero() {
+		t.Error(tm)
+	}
+
+	var nt sql.NullTime
+	err = db.QueryRow(`SELECT NULL`).Scan(&nt)
+	if err != nil {
+		t.Error(err)
+	}
+	// Go 1.27
+	err = db.QueryRow(`SELECT datetime()`).Scan(&nt)
+	if err != nil && !strings.HasPrefix(err.Error(), "sql: Scan error") {
+		t.Error(err)
+	}
+	if err == nil && nt.Time.IsZero() {
+		t.Error(nt.Time)
+	}
+}
+
+func Benchmark_loop(b *testing.B) {
+	ctx := testcfg.Context(b)
+	db, err := Open(":memory:")
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer db.Close()
+
+	var version string
+	err = db.QueryRowContext(ctx, `SELECT sqlite_version();`).Scan(&version)
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	for b.Loop() {
+		_, err := db.ExecContext(b.Context(),
+			`WITH RECURSIVE c(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM c WHERE x < 1000000) SELECT x FROM c;`)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}

driver/example2_test.go

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

driver/example_test.go

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

driver/json_test.go

@@ -4,10 +4,9 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/ncruces/go-sqlite3"
-	"github.com/ncruces/go-sqlite3/driver"
-	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/vfs/memdb"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/driver"
+	_ "github.com/hanzoai/sqlite3/vfs/memdb"
 )
 
 func Example_json() {

driver/savepoint.go

@@ -4,7 +4,7 @@ import (
 	"database/sql"
 	"time"
 
-	"github.com/ncruces/go-sqlite3"
+	"github.com/hanzoai/sqlite3"
 )
 
 // Savepoint establishes a new transaction savepoint.

driver/savepoint_test.go

@@ -4,9 +4,8 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/ncruces/go-sqlite3/driver"
-	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/vfs/memdb"
+	"github.com/hanzoai/sqlite3/driver"
+	_ "github.com/hanzoai/sqlite3/vfs/memdb"
 )
 
 func ExampleSavepoint() {

driver/time.go

@@ -1,14 +1,23 @@
 package driver
 
 import (
+	"bytes"
 	"time"
 )
 
 // Convert a string in [time.RFC3339Nano] format into a [time.Time]
-// if it roundtrips back to the same string.
+// if that's the format we're using to persist them,
+// and if it roundtrips back to the same string.
 // This way times can be persisted to, and recovered from, the database,
-// but if a string is needed, [database/sql] will recover the same string.
-func maybeTime(text string) (_ time.Time, _ bool) {
+// but if a string is wanted, [database/sql] will recover the same string.
+func (r *rows) maybeTime(text []byte) (_ time.Time, _ bool) {
+	switch r.tmWrite {
+	case "", time.RFC3339, time.RFC3339Nano:
+		break
+	default:
+		return
+	}
+
 	// Weed out (some) values that can't possibly be
 	// [time.RFC3339Nano] timestamps.
 	if len(text) < len("2006-01-02T15:04:05Z") {
@@ -23,8 +32,8 @@ func maybeTime(text string) (_ time.Time, _ bool) {
 
 	// Slow path.
 	var buf [len(time.RFC3339Nano)]byte
-	date, err := time.Parse(time.RFC3339Nano, text)
-	if err == nil && text == string(date.AppendFormat(buf[:0], time.RFC3339Nano)) {
+	date, err := time.Parse(time.RFC3339Nano, string(text))
+	if err == nil && bytes.Equal(text, date.AppendFormat(buf[:0], time.RFC3339Nano)) {
 		return date, true
 	}
 	return

driver/time_test.go

@@ -21,18 +21,19 @@ func Fuzz_stringOrTime_1(f *testing.F) {
 	f.Add("2006-01-02T15:04:05.9999999999Z")
 	f.Add("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.")
 
+	r := rows{stmt: &stmt{}}
 	f.Fuzz(func(t *testing.T, str string) {
-		v, ok := maybeTime(str)
+		v, ok := r.maybeTime([]byte(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)
+				t.Errorf("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)
+				t.Errorf("would round-trip: %q", str)
 			}
 		}
 	})
@@ -50,8 +51,9 @@ func Fuzz_stringOrTime_2(f *testing.F) {
 	f.Add(int64(639095955742), int64(222_222_222))  // twosday, year 22222AD
 	f.Add(int64(-763421161058), int64(222_222_222)) // twosday, year 22222BC
 
+	r := rows{stmt: &stmt{}}
 	checkTime := func(t testing.TB, date time.Time) {
-		v, ok := maybeTime(date.Format(time.RFC3339Nano))
+		v, ok := r.maybeTime(date.AppendFormat(nil, time.RFC3339Nano))
 		if ok {
 			// Make sure times round-trip to the same time:
 			if !v.Equal(date) {

driver/util.go

@@ -12,3 +12,63 @@ func namedValues(args []driver.Value) []driver.NamedValue {
 	}
 	return named
 }
+
+func notWhitespace(sql string) bool {
+	const (
+		code = iota
+		slash
+		minus
+		ccomment
+		sqlcomment
+		endcomment
+	)
+
+	state := code
+	for _, b := range ([]byte)(sql) {
+		if b == 0 {
+			break
+		}
+
+		switch state {
+		case code:
+			switch b {
+			case '/':
+				state = slash
+			case '-':
+				state = minus
+			case ' ', ';', '\t', '\n', '\v', '\f', '\r':
+				continue
+			default:
+				return true
+			}
+		case slash:
+			if b != '*' {
+				return true
+			}
+			state = ccomment
+		case minus:
+			if b != '-' {
+				return true
+			}
+			state = sqlcomment
+		case ccomment:
+			if b == '*' {
+				state = endcomment
+			}
+		case sqlcomment:
+			if b == '\n' {
+				state = code
+			}
+		case endcomment:
+			switch b {
+			case '/':
+				state = code
+			case '*':
+				state = endcomment
+			default:
+				state = ccomment
+			}
+		}
+	}
+	return state == slash || state == minus
+}

driver/util_test.go

@@ -2,8 +2,10 @@ package driver
 
 import (
 	"database/sql/driver"
-	"reflect"
+	"slices"
 	"testing"
+
+	"github.com/hanzoai/sqlite3/internal/testcfg"
 )
 
 func Test_namedValues(t *testing.T) {
@@ -12,7 +14,72 @@ func Test_namedValues(t *testing.T) {
 		{Ordinal: 2, Value: false},
 	}
 	got := namedValues([]driver.Value{true, false})
-	if !reflect.DeepEqual(got, want) {
+	if !slices.Equal(got, want) {
 		t.Errorf("got %v, want %v", got, want)
 	}
 }
+
+func Fuzz_notWhitespace(f *testing.F) {
+	f.Add("")
+	f.Add(" ")
+	f.Add(";")
+	f.Add("0")
+	f.Add("-")
+	f.Add("-0")
+	f.Add("--")
+	f.Add("--0")
+	f.Add("--\n")
+	f.Add("--0\n")
+	f.Add("/0")
+	f.Add("/*")
+	f.Add("/*/")
+	f.Add("/**")
+	f.Add("/*0")
+	f.Add("/**/")
+	f.Add("/***/")
+	f.Add("/**0/")
+	f.Add("\v")
+	f.Add(" \v")
+	f.Add("\xf0")
+	f.Add("\000")
+
+	db, err := Open(":memory:")
+	if err != nil {
+		f.Fatal(err)
+	}
+	defer db.Close()
+
+	f.Fuzz(func(t *testing.T, str string) {
+		if len(str) > 128 {
+			t.SkipNow()
+		}
+
+		ctx := testcfg.Context(t)
+		c, err := db.Conn(ctx)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer c.Close()
+
+		c.Raw(func(driverConn any) error {
+			conn := driverConn.(*conn).Conn
+			stmt, tail, err := conn.Prepare(str)
+			stmt.Close()
+
+			// It's hard to be bug for bug compatible with SQLite.
+			// We settle for somewhat less:
+			//   - if SQLite reports whitespace, we must too
+			//   - if we report whitespace, SQLite must not parse a statement
+			if notWhitespace(str) {
+				if stmt == nil && tail == "" && err == nil {
+					t.Errorf("was whitespace: %q", str)
+				}
+			} else {
+				if stmt != nil {
+					t.Errorf("was not whitespace: %q (%v)", str, err)
+				}
+			}
+			return nil
+		})
+	})
+}

embed/README.md

@@ -1,40 +0,0 @@
-# Embeddable Wasm build of SQLite
-
-This folder includes an embeddable Wasm build of SQLite 3.46.1 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)
-- [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)
-- [time](../sqlite3/time.c)
-
-See the [configuration options](../sqlite3/sqlite_opt.h),
-and [patches](../sqlite3) applied.
-
-Built using [`wasi-sdk`](https://github.com/WebAssembly/wasi-sdk),
-and [`binaryen`](https://github.com/WebAssembly/binaryen).
-
-The build is easily reproducible, and verifiable, using
-[Artifact Attestations](https://github.com/ncruces/go-sqlite3/attestations).
-
-### Customizing the build
-
-You can use your own custom build of SQLite.
-
-Examples of custom builds of SQLite are:
-- [`github.com/ncruces/go-sqlite3/embed/bcw2`](https://github.com/ncruces/go-sqlite3/tree/main/embed/bcw2)
-  built from a branch supporting [`BEGIN CONCURRENT`](https://sqlite.org/src/doc/begin-concurrent/doc/begin_concurrent.md)
-  and [Wal2](https://www.sqlite.org/cgi/src/doc/wal2/doc/wal2.md).
-- [`github.com/asg017/sqlite-vec-go-bindings/ncruces`](https://github.com/asg017/sqlite-vec-go-bindings)
-  which includes the [`sqlite-vec`](https://github.com/asg017/sqlite-vec) vector search extension.

embed/bcw2/.gitignore

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

embed/bcw2/README.md

@@ -1,16 +0,0 @@
-# Embeddable Wasm build of SQLite
-
-This folder includes an embeddable Wasm build of SQLite 3.46.1, including the experimental
-[`BEGIN CONCURRENT`](https://sqlite.org/src/doc/begin-concurrent/doc/begin_concurrent.md) and
-[Wal2](https://www.sqlite.org/cgi/src/doc/wal2/doc/wal2.md) patches.
-
-> [!IMPORTANT]  
-> This package is experimental.
-> It is built from the `bedrock` branch of SQLite,
-> since that is _currently_ the most stable, maintained branch to include both features.
-
-> [!CAUTION]
-> The Wal2 journaling mode creates databases that other versions of SQLite cannot access.
-
-The build is easily reproducible, and verifiable, using
-[Artifact Attestations](https://github.com/ncruces/go-sqlite3/attestations).

embed/bcw2/bcw2_test.go

@@ -1,48 +0,0 @@
-package bcw2
-
-import (
-	"path/filepath"
-	"testing"
-
-	"github.com/ncruces/go-sqlite3/driver"
-	"github.com/ncruces/go-sqlite3/vfs"
-)
-
-func Test_bcw2(t *testing.T) {
-	if !vfs.SupportsSharedMemory {
-		t.Skip("skipping without shared memory")
-	}
-
-	tmp := filepath.ToSlash(filepath.Join(t.TempDir(), "test.db"))
-
-	db, err := driver.Open("file:" + tmp + "?_pragma=journal_mode(wal2)&_txlock=concurrent")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db.Close()
-
-	tx, err := db.Begin()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer tx.Rollback()
-
-	_, err = tx.Exec(`CREATE TABLE test (col)`)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = tx.Commit()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	var version string
-	err = db.QueryRow(`SELECT sqlite_version()`).Scan(&version)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if version != "3.46.1" {
-		t.Error(version)
-	}
-}

embed/bcw2/build.sh

@@ -1,63 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-cd -P -- "$(dirname -- "$0")"
-
-ROOT=../../
-BINARYEN="$ROOT/tools/binaryen/bin"
-WASI_SDK="$ROOT/tools/wasi-sdk/bin"
-
-trap 'rm -rf build/ sqlite/ bcw2.tmp' EXIT
-
-mkdir -p build/ext/
-cp "$ROOT"/sqlite3/*.[ch] build/
-cp "$ROOT"/sqlite3/*.patch build/
-
-curl -# https://www.sqlite.org/src/tarball/sqlite.tar.gz?r=bedrock-3.46 | tar xz
-
-cd sqlite
-if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" ]]; then
-	MSYS_NO_PATHCONV=1 nmake /f makefile.msc sqlite3.c
-else
-	sh configure
-	make sqlite3.c
-fi
-cd ~-
-
-mv sqlite/sqlite3.c             build/
-mv sqlite/sqlite3.h             build/
-mv sqlite/sqlite3ext.h          build/
-mv sqlite/ext/misc/anycollseq.c build/ext/
-mv sqlite/ext/misc/base64.c     build/ext/
-mv sqlite/ext/misc/decimal.c    build/ext/
-mv sqlite/ext/misc/ieee754.c    build/ext/
-mv sqlite/ext/misc/regexp.c     build/ext/
-mv sqlite/ext/misc/series.c     build/ext/
-mv sqlite/ext/misc/uint.c       build/ext/
-
-cd build
-cat *.patch | patch --no-backup-if-mismatch
-cd ~-
-
-"$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -g0 -O2 \
-	-Wall -Wextra -Wno-unused-parameter -Wno-unused-function \
-	-o bcw2.wasm "build/main.c" \
-	-I"build" \
-	-mexec-model=reactor \
-	-matomics -msimd128 -mmutable-globals \
-	-mbulk-memory -mreference-types \
-	-mnontrapping-fptoint -msign-ext \
-	-fno-stack-protector -fno-stack-clash-protection \
-	-Wl,--stack-first \
-	-Wl,--import-undefined \
-	-Wl,--initial-memory=327680 \
-	-D_HAVE_SQLITE_CONFIG_H \
-	-DSQLITE_CUSTOM_INCLUDE=sqlite_opt.h \
-	$(awk '{print "-Wl,--export="$0}' ../exports.txt)
-
-"$BINARYEN/wasm-ctor-eval" -g -c _initialize bcw2.wasm -o bcw2.tmp
-"$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
-	bcw2.tmp -o bcw2.wasm \
-	--enable-simd --enable-mutable-globals --enable-multivalue \
-	--enable-bulk-memory --enable-reference-types \
-	--enable-nontrapping-float-to-int --enable-sign-ext

embed/bcw2/init.go

@@ -1,23 +0,0 @@
-// Package bcw2 embeds SQLite into your application.
-//
-// Importing package bcw2 initializes the [sqlite3.Binary] variable
-// with a build of SQLite that includes the [BEGIN CONCURRENT] and [Wal2] patches:
-//
-//	import _ "github.com/ncruces/go-sqlite3/embed/bcw2"
-//
-// [BEGIN CONCURRENT]: https://sqlite.org/src/doc/begin-concurrent/doc/begin_concurrent.md
-// [Wal2]: https://www.sqlite.org/cgi/src/doc/wal2/doc/wal2.md
-package bcw2
-
-import (
-	_ "embed"
-
-	"github.com/ncruces/go-sqlite3"
-)
-
-//go:embed bcw2.wasm
-var binary []byte
-
-func init() {
-	sqlite3.Binary = binary
-}

embed/build.sh

@@ -1,33 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-cd -P -- "$(dirname -- "$0")"
-
-ROOT=../
-BINARYEN="$ROOT/tools/binaryen/bin"
-WASI_SDK="$ROOT/tools/wasi-sdk/bin"
-
-trap 'rm -f sqlite3.tmp' EXIT
-
-"$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -g0 -O2 \
-	-Wall -Wextra -Wno-unused-parameter -Wno-unused-function \
-	-o sqlite3.wasm "$ROOT/sqlite3/main.c" \
-	-I"$ROOT/sqlite3" \
-	-mexec-model=reactor \
-	-matomics -msimd128 -mmutable-globals \
-	-mbulk-memory -mreference-types \
-	-mnontrapping-fptoint -msign-ext \
-	-fno-stack-protector -fno-stack-clash-protection \
-	-Wl,--stack-first \
-	-Wl,--import-undefined \
-	-Wl,--initial-memory=327680 \
-	-D_HAVE_SQLITE_CONFIG_H \
-	-DSQLITE_CUSTOM_INCLUDE=sqlite_opt.h \
-	$(awk '{print "-Wl,--export="$0}' exports.txt)
-
-"$BINARYEN/wasm-ctor-eval" -g -c _initialize sqlite3.wasm -o sqlite3.tmp
-"$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 \
-	--enable-nontrapping-float-to-int --enable-sign-ext

embed/embed.go

@@ -0,0 +1,8 @@
+// Package embed is no longer needed.
+//
+// Deprecated: importing github.com/hanzoai/sqlite3/embed is unnecessary.
+package embed
+
+func init() {
+	println("If you're reading this, you're unnecessarily importing github.com/hanzoai/sqlite3/embed.")
+}

embed/exports.txt

@@ -1,138 +0,0 @@
-aligned_alloc
-sqlite3_anycollseq_init
-sqlite3_autovacuum_pages_go
-sqlite3_backup_finish
-sqlite3_backup_init
-sqlite3_backup_pagecount
-sqlite3_backup_remaining
-sqlite3_backup_step
-sqlite3_bind_blob_go
-sqlite3_bind_double
-sqlite3_bind_int64
-sqlite3_bind_null
-sqlite3_bind_parameter_count
-sqlite3_bind_parameter_index
-sqlite3_bind_parameter_name
-sqlite3_bind_pointer_go
-sqlite3_bind_text_go
-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_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_module_go
-sqlite3_create_window_function_go
-sqlite3_database_file_object
-sqlite3_db_cacheflush
-sqlite3_db_config
-sqlite3_db_filename
-sqlite3_db_name
-sqlite3_db_readonly
-sqlite3_db_release_memory
-sqlite3_db_status
-sqlite3_declare_vtab
-sqlite3_errcode
-sqlite3_errmsg
-sqlite3_error_offset
-sqlite3_errstr
-sqlite3_exec
-sqlite3_expanded_sql
-sqlite3_file_control
-sqlite3_filename_database
-sqlite3_filename_journal
-sqlite3_filename_wal
-sqlite3_finalize
-sqlite3_free
-sqlite3_get_autocommit
-sqlite3_get_auxdata
-sqlite3_hard_heap_limit64
-sqlite3_interrupt
-sqlite3_last_insert_rowid
-sqlite3_limit
-sqlite3_malloc64
-sqlite3_open_v2
-sqlite3_overload_function
-sqlite3_prepare_v3
-sqlite3_progress_handler_go
-sqlite3_realloc64
-sqlite3_reset
-sqlite3_result_blob_go
-sqlite3_result_double
-sqlite3_result_error
-sqlite3_result_error_code
-sqlite3_result_error_nomem
-sqlite3_result_error_toobig
-sqlite3_result_int64
-sqlite3_result_null
-sqlite3_result_pointer_go
-sqlite3_result_text_go
-sqlite3_result_value
-sqlite3_result_zeroblob64
-sqlite3_rollback_hook_go
-sqlite3_set_authorizer_go
-sqlite3_set_auxdata_go
-sqlite3_set_last_insert_rowid
-sqlite3_soft_heap_limit64
-sqlite3_step
-sqlite3_stmt_busy
-sqlite3_stmt_readonly
-sqlite3_stmt_status
-sqlite3_table_column_metadata
-sqlite3_total_changes64
-sqlite3_trace_go
-sqlite3_txn_state
-sqlite3_update_hook_go
-sqlite3_uri_key
-sqlite3_value_blob
-sqlite3_value_bytes
-sqlite3_value_double
-sqlite3_value_dup
-sqlite3_value_free
-sqlite3_value_frombind
-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_nochange
-sqlite3_vtab_on_conflict
-sqlite3_vtab_rhs_value
-sqlite3_wal_autocheckpoint
-sqlite3_wal_checkpoint_v2
-sqlite3_wal_hook_go

embed/init.go

@@ -1,20 +0,0 @@
-// Package embed embeds SQLite into your application.
-//
-// Importing package embed initializes the [sqlite3.Binary] variable
-// with an appropriate build of SQLite:
-//
-//	import _ "github.com/ncruces/go-sqlite3/embed"
-package embed
-
-import (
-	_ "embed"
-
-	"github.com/ncruces/go-sqlite3"
-)
-
-//go:embed sqlite3.wasm
-var binary []byte
-
-func init() {
-	sqlite3.Binary = binary
-}

embed/init_test.go

@@ -1,25 +0,0 @@
-package embed
-
-import (
-	"testing"
-
-	"github.com/ncruces/go-sqlite3/driver"
-	_ "github.com/ncruces/go-sqlite3/vfs/memdb"
-)
-
-func Test_init(t *testing.T) {
-	db, err := driver.Open("file:/test.db?vfs=memdb")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db.Close()
-
-	var version string
-	err = db.QueryRow(`SELECT sqlite_version()`).Scan(&version)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if version != "3.46.1" {
-		t.Error(version)
-	}
-}

error.go

@@ -2,20 +2,19 @@ package sqlite3
 
 import (
 	"errors"
-	"strconv"
 	"strings"
 
-	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/hanzoai/sqlite3/internal/sqlite3_wrap"
 )
 
 // Error wraps an SQLite Error Code.
 //
 // https://sqlite.org/c3ref/errcode.html
 type Error struct {
-	str  string
+	sys  error
 	msg  string
 	sql  string
-	code uint64
+	code res_t
 }
 
 // Code returns the primary error code for this error.
@@ -29,28 +28,34 @@ func (e *Error) Code() ErrorCode {
 //
 // https://sqlite.org/rescode.html
 func (e *Error) ExtendedCode() ExtendedErrorCode {
-	return ExtendedErrorCode(e.code)
+	return xErrorCode(e.code)
 }
 
 // Error implements the error interface.
 func (e *Error) Error() string {
 	var b strings.Builder
-	b.WriteString("sqlite3: ")
-
-	if e.str != "" {
-		b.WriteString(e.str)
-	} else {
-		b.WriteString(strconv.Itoa(int(e.code)))
-	}
+	b.WriteString(sqlite3_wrap.ErrorCodeString(e.code))
 
 	if e.msg != "" {
 		b.WriteString(": ")
 		b.WriteString(e.msg)
 	}
+	if e.sys != nil {
+		b.WriteString(": ")
+		b.WriteString(e.sys.Error())
+	}
 
 	return b.String()
 }
 
+// Unwrap returns the underlying operating system error
+// that caused the I/O error or failure to open a file.
+//
+// https://sqlite.org/c3ref/system_errno.html
+func (e *Error) Unwrap() error {
+	return e.sys
+}
+
 // Is tests whether this error matches a given [ErrorCode] or [ExtendedErrorCode].
 //
 // It makes it possible to do:
@@ -83,7 +88,7 @@ func (e *Error) As(err any) bool {
 
 // Temporary returns true for [BUSY] errors.
 func (e *Error) Temporary() bool {
-	return e.Code() == BUSY
+	return e.Code() == BUSY || e.Code() == INTERRUPT
 }
 
 // Timeout returns true for [BUSY_TIMEOUT] errors.
@@ -98,17 +103,31 @@ func (e *Error) SQL() string {
 
 // Error implements the error interface.
 func (e ErrorCode) Error() string {
-	return util.ErrorCodeString(uint32(e))
+	return sqlite3_wrap.ErrorCodeString(e)
+}
+
+// As converts this error to an [ExtendedErrorCode].
+func (e ErrorCode) As(err any) bool {
+	c, ok := err.(*xErrorCode)
+	if ok {
+		*c = xErrorCode(e)
+	}
+	return ok
 }
 
 // Temporary returns true for [BUSY] errors.
 func (e ErrorCode) Temporary() bool {
-	return e == BUSY
+	return e == BUSY || e == INTERRUPT
+}
+
+// ExtendedCode returns the extended error code for this error.
+func (e ErrorCode) ExtendedCode() ExtendedErrorCode {
+	return xErrorCode(e)
 }
 
 // Error implements the error interface.
 func (e ExtendedErrorCode) Error() string {
-	return util.ErrorCodeString(uint32(e))
+	return sqlite3_wrap.ErrorCodeString(e)
 }
 
 // Is tests whether this error matches a given [ErrorCode].
@@ -128,7 +147,7 @@ func (e ExtendedErrorCode) As(err any) bool {
 
 // Temporary returns true for [BUSY] errors.
 func (e ExtendedErrorCode) Temporary() bool {
-	return ErrorCode(e) == BUSY
+	return ErrorCode(e) == BUSY || ErrorCode(e) == INTERRUPT
 }
 
 // Timeout returns true for [BUSY_TIMEOUT] errors.
@@ -136,27 +155,28 @@ func (e ExtendedErrorCode) Timeout() bool {
 	return e == BUSY_TIMEOUT
 }
 
-func errorCode(err error, def ErrorCode) (msg string, code uint32) {
+// Code returns the primary error code for this error.
+func (e ExtendedErrorCode) Code() ErrorCode {
+	return ErrorCode(e)
+}
+
+func errorCode(err error, def ErrorCode) (msg string, code res_t) {
 	switch code := err.(type) {
 	case nil:
 		return "", _OK
 	case ErrorCode:
-		return "", uint32(code)
+		return "", res_t(code)
 	case xErrorCode:
-		return "", uint32(code)
+		return "", res_t(code)
 	case *Error:
-		return code.msg, uint32(code.code)
+		return code.msg, res_t(code.code)
 	}
 
-	var ecode ErrorCode
 	var xcode xErrorCode
-	switch {
-	case errors.As(err, &xcode):
-		code = uint32(xcode)
-	case errors.As(err, &ecode):
-		code = uint32(ecode)
-	default:
-		code = uint32(def)
+	if errors.As(err, &xcode) {
+		code = res_t(xcode)
+	} else {
+		code = res_t(def)
 	}
 	return err.Error(), code
 }

error_test.go

@@ -6,12 +6,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/hanzoai/sqlite3/internal/errutil"
+	"github.com/hanzoai/sqlite3/internal/sqlite3_wrap"
 )
 
 func Test_assertErr(t *testing.T) {
-	err := util.AssertErr()
-	if s := err.Error(); !strings.HasPrefix(s, "sqlite3: assertion failed") || !strings.HasSuffix(s, "error_test.go:13)") {
+	err := errutil.AssertErr()
+	if s := err.Error(); !strings.HasPrefix(s, "sqlite3: assertion failed") || !strings.HasSuffix(s, "error_test.go:14)") {
 		t.Errorf("got %q", s)
 	}
 }
@@ -43,7 +44,7 @@ func TestError(t *testing.T) {
 	if !errors.Is(err, xErrorCode(0x8080)) {
 		t.Errorf("want true")
 	}
-	if s := err.Error(); s != "sqlite3: 32896" {
+	if s := err.Error(); s != "sqlite3: unknown error" {
 		t.Errorf("got %q", s)
 	}
 	if ok := errors.As(err.ExtendedCode(), &ecode); !ok || ecode != ErrorCode(0x80) {
@@ -59,14 +60,14 @@ func TestError_Temporary(t *testing.T) {
 
 	tests := []struct {
 		name string
-		code uint64
+		code res_t
 		want bool
 	}{
-		{"ERROR", uint64(ERROR), false},
-		{"BUSY", uint64(BUSY), true},
-		{"BUSY_RECOVERY", uint64(BUSY_RECOVERY), true},
-		{"BUSY_SNAPSHOT", uint64(BUSY_SNAPSHOT), true},
-		{"BUSY_TIMEOUT", uint64(BUSY_TIMEOUT), true},
+		{"ERROR", res_t(ERROR), false},
+		{"BUSY", res_t(BUSY), true},
+		{"BUSY_RECOVERY", res_t(BUSY_RECOVERY), true},
+		{"BUSY_SNAPSHOT", res_t(BUSY_SNAPSHOT), true},
+		{"BUSY_TIMEOUT", res_t(BUSY_TIMEOUT), true},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -83,7 +84,7 @@ func TestError_Temporary(t *testing.T) {
 				}
 			}
 			{
-				err := ExtendedErrorCode(tt.code)
+				err := xErrorCode(tt.code)
 				if got := err.Temporary(); got != tt.want {
 					t.Errorf("ExtendedErrorCode.Temporary(%d) = %v, want %v", tt.code, got, tt.want)
 				}
@@ -97,14 +98,14 @@ func TestError_Timeout(t *testing.T) {
 
 	tests := []struct {
 		name string
-		code uint64
+		code res_t
 		want bool
 	}{
-		{"ERROR", uint64(ERROR), false},
-		{"BUSY", uint64(BUSY), false},
-		{"BUSY_RECOVERY", uint64(BUSY_RECOVERY), false},
-		{"BUSY_SNAPSHOT", uint64(BUSY_SNAPSHOT), false},
-		{"BUSY_TIMEOUT", uint64(BUSY_TIMEOUT), true},
+		{"ERROR", res_t(ERROR), false},
+		{"BUSY", res_t(BUSY), false},
+		{"BUSY_RECOVERY", res_t(BUSY_RECOVERY), false},
+		{"BUSY_SNAPSHOT", res_t(BUSY_SNAPSHOT), false},
+		{"BUSY_TIMEOUT", res_t(BUSY_TIMEOUT), true},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -115,7 +116,7 @@ func TestError_Timeout(t *testing.T) {
 				}
 			}
 			{
-				err := ExtendedErrorCode(tt.code)
+				err := xErrorCode(tt.code)
 				if got := err.Timeout(); got != tt.want {
 					t.Errorf("Error.Timeout(%d) = %v, want %v", tt.code, got, tt.want)
 				}
@@ -127,7 +128,7 @@ func TestError_Timeout(t *testing.T) {
 func Test_ErrorCode_Error(t *testing.T) {
 	t.Parallel()
 
-	db, err := Open(":memory:")
+	db, err := OpenContext(testContext(t), ":memory:")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -136,8 +137,8 @@ func Test_ErrorCode_Error(t *testing.T) {
 	// Test all error codes.
 	for i := 0; i == int(ErrorCode(i)); i++ {
 		want := "sqlite3: "
-		r := db.call("sqlite3_errstr", uint64(i))
-		want += util.ReadString(db.mod, uint32(r), _MAX_NAME)
+		ptr := ptr_t(db.wrp.Xsqlite3_errstr(int32(i)))
+		want += db.wrp.ReadString(ptr, _MAX_NAME)
 
 		got := ErrorCode(i).Error()
 		if got != want {
@@ -149,19 +150,19 @@ func Test_ErrorCode_Error(t *testing.T) {
 func Test_ExtendedErrorCode_Error(t *testing.T) {
 	t.Parallel()
 
-	db, err := Open(":memory:")
+	db, err := OpenContext(testContext(t), ":memory:")
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db.Close()
 
 	// Test all extended error codes.
-	for i := 0; i == int(ExtendedErrorCode(i)); i++ {
+	for i := 0; i == int(xErrorCode(i)); i++ {
 		want := "sqlite3: "
-		r := db.call("sqlite3_errstr", uint64(i))
-		want += util.ReadString(db.mod, uint32(r), _MAX_NAME)
+		ptr := ptr_t(db.wrp.Xsqlite3_errstr(int32(i)))
+		want += db.wrp.ReadString(ptr, _MAX_NAME)
 
-		got := ExtendedErrorCode(i).Error()
+		got := xErrorCode(i).Error()
 		if got != want {
 			t.Fatalf("got %q, want %q, with %d", got, want, i)
 		}
@@ -172,17 +173,17 @@ func Test_errorCode(t *testing.T) {
 	tests := []struct {
 		arg      error
 		wantMsg  string
-		wantCode uint32
+		wantCode res_t
 	}{
 		{nil, "", _OK},
-		{ERROR, "", util.ERROR},
-		{IOERR, "", util.IOERR},
-		{IOERR_READ, "", util.IOERR_READ},
-		{&Error{code: util.ERROR}, "", util.ERROR},
-		{fmt.Errorf("%w", ERROR), ERROR.Error(), util.ERROR},
-		{fmt.Errorf("%w", IOERR), IOERR.Error(), util.IOERR},
-		{fmt.Errorf("%w", IOERR_READ), IOERR_READ.Error(), util.IOERR_READ},
-		{fmt.Errorf("error"), "error", util.ERROR},
+		{ERROR, "", sqlite3_wrap.ERROR},
+		{IOERR, "", sqlite3_wrap.IOERR},
+		{IOERR_READ, "", sqlite3_wrap.IOERR_READ},
+		{&Error{code: sqlite3_wrap.ERROR}, "", sqlite3_wrap.ERROR},
+		{fmt.Errorf("%w", ERROR), ERROR.Error(), sqlite3_wrap.ERROR},
+		{fmt.Errorf("%w", IOERR), IOERR.Error(), sqlite3_wrap.IOERR},
+		{fmt.Errorf("%w", IOERR_READ), IOERR_READ.Error(), sqlite3_wrap.IOERR_READ},
+		{fmt.Errorf("error"), "error", sqlite3_wrap.ERROR},
 	}
 	for _, tt := range tests {
 		t.Run("", func(t *testing.T) {
@@ -190,7 +191,7 @@ func Test_errorCode(t *testing.T) {
 			if gotMsg != tt.wantMsg {
 				t.Errorf("errorCode() gotMsg = %q, want %q", gotMsg, tt.wantMsg)
 			}
-			if gotCode != uint32(tt.wantCode) {
+			if gotCode != tt.wantCode {
 				t.Errorf("errorCode() gotCode = %d, want %d", gotCode, tt.wantCode)
 			}
 		})

example_test.go

@@ -4,8 +4,7 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/ncruces/go-sqlite3"
-	_ "github.com/ncruces/go-sqlite3/embed"
+	"github.com/hanzoai/sqlite3"
 )
 
 const memory = ":memory:"

ext.go

@@ -0,0 +1,138 @@
+package sqlite3
+
+import (
+	"bytes"
+	"encoding/base64"
+	"sync"
+
+	"github.com/hanzoai/sqlite3/internal/errutil"
+)
+
+var (
+	// +checklocks:extRegistryMtx
+	extRegistry    []func(*Conn) error
+	extRegistryMtx sync.RWMutex
+)
+
+// AutoExtension causes the entryPoint function to be invoked
+// for each new database connection that is created.
+//
+// https://sqlite.org/c3ref/auto_extension.html
+func AutoExtension(entryPoint func(*Conn) error) {
+	extRegistryMtx.Lock()
+	extRegistry = append(extRegistry, entryPoint)
+	extRegistryMtx.Unlock()
+}
+
+func initExtensions(c *Conn) error {
+	c.base64()
+	extRegistryMtx.RLock()
+	defer extRegistryMtx.RUnlock()
+	for _, f := range extRegistry {
+		if err := f(c); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (c *Conn) base64() error {
+	return c.CreateFunction("base64", 1, DETERMINISTIC, func(ctx Context, arg ...Value) {
+		switch a := arg[0]; a.Type() {
+		case NULL:
+
+		case BLOB:
+			data := a.RawBlob()
+			code := base64.StdEncoding
+			size := int64(code.EncodedLen(len(data)))
+			if size > _MAX_LENGTH {
+				ctx.ResultError(TOOBIG)
+				return
+			}
+			ptr := c.wrp.New(size)
+			if size > 0 {
+				code.Encode(c.wrp.Bytes(ptr, size), data)
+			}
+			ctx.c.wrp.Xsqlite3_result_text_go(int32(ctx.handle), int32(ptr), size)
+
+		case TEXT:
+			data := a.RawText()
+			data = bytes.Trim(data, " \t\n\v\f\r")
+			data = bytes.TrimRight(data, "=")
+			code := base64.RawStdEncoding
+			size := int64(code.DecodedLen(len(data)))
+			if size > _MAX_LENGTH {
+				ctx.ResultError(TOOBIG)
+				return
+			}
+			ptr := c.wrp.New(size)
+			if size > 0 {
+				n, _ := code.Decode(c.wrp.Bytes(ptr, size), data)
+				size = int64(n)
+			}
+			ctx.c.wrp.Xsqlite3_result_blob_go(int32(ctx.handle), int32(ptr), size)
+
+		default:
+			ctx.ResultError(errutil.ErrorString("base64: accepts only blob or text"))
+		}
+	})
+}
+
+// ExtensionLibrary represents a dynamically linked SQLite extension.
+type ExtensionLibrary interface {
+	Xsqlite3_extension_init(db, _, _ int32) int32
+}
+
+// ExtensionInfo returns values needed to load a dynamically linked SQLite extension.
+type ExtensionInfo func() (memorySize, memoryAlignment, tableSize, tableAlignment int64)
+
+type extEnv struct {
+	*env
+	memoryBase int32
+	tableBase  int32
+}
+
+func (e *extEnv) X__memory_base() *int32 { return &e.memoryBase }
+func (e *extEnv) X__table_base() *int32  { return &e.tableBase }
+
+// ExtensionInit loads an SQLite extension library.
+//
+// https://sqlite.org/loadext.html
+func ExtensionInit[Env any, Mod ExtensionLibrary](db *Conn, init func(env Env) Mod, info ExtensionInfo) error {
+	memSize, memAlign, tableSize, tableAlign := info()
+
+	var memBase int32
+	if memSize > 0 {
+		memBase = db.wrp.Xaligned_alloc(int32(memAlign), int32(memSize))
+		if memBase == 0 {
+			panic(errutil.OOMErr)
+		}
+	}
+
+	var tableBase int
+	if tableSize > 0 {
+		// Round up to the alignment.
+		rnd := int(tableAlign) - 1
+		tab := db.wrp.X__indirect_function_table()
+		tableBase = (len(*tab) + rnd) &^ rnd
+		if add := tableBase + int(tableSize) - len(*tab); add > 0 {
+			*tab = append(*tab, make([]any, add)...)
+		}
+	}
+
+	e := &extEnv{
+		env:        &env{db.wrp},
+		memoryBase: memBase,
+		tableBase:  int32(tableBase),
+	}
+
+	mod := init(any(e).(Env))
+	if opt, ok := any(mod).(interface{ X__wasm_apply_data_relocs() }); ok {
+		opt.X__wasm_apply_data_relocs()
+	}
+	if opt, ok := any(mod).(interface{ X__wasm_call_ctors() }); ok {
+		opt.X__wasm_call_ctors()
+	}
+	rc := mod.Xsqlite3_extension_init(int32(db.handle), 0, 0)
+	return db.error(res_t(rc))
+}

ext/README.md

@@ -0,0 +1,58 @@
+# Go SQLite Extensions
+
+This folder collects optional SQLite extensions
+you can load into your database connections.
+
+### Extensions
+
+- [`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/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/closure`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/closure)
+  provides a transitive closure virtual table.
+- [`github.com/ncruces/go-sqlite3/ext/csv`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/csv)
+  reads [comma-separated values](https://sqlite.org/csv.html).
+- [`github.com/ncruces/go-sqlite3/ext/fileio`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/fileio)
+  reads, writes and lists files.
+- [`github.com/ncruces/go-sqlite3/ext/fts5`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/fts5)
+  provides [full-text search](https://sqlite.org/fts5.html).
+- [`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/ipaddr`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/ipaddr)
+  provides functions to manipulate IPs and CIDRs.
+- [`github.com/ncruces/go-sqlite3/ext/lines`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/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/regexp`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/regexp)
+  provides [regular expression](https://github.com/nalgeon/sqlean/blob/main/docs/regexp.md) functions.
+- [`github.com/ncruces/go-sqlite3/ext/rtree`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/rtree)
+  provides [multi-dimensional](https://sqlite.org/rtree.html) and [geospatial](https://sqlite.org/geopoly.html) indexes.
+- [`github.com/ncruces/go-sqlite3/ext/serdes`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/serdes)
+  (de)serializes databases.
+- [`github.com/ncruces/go-sqlite3/ext/spellfix1`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/spellfix1)
+  searches a vocabulary for [close matches](https://sqlite.org/spellfix1.html).
+- [`github.com/ncruces/go-sqlite3/ext/statement`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/statement)
+  creates [parameterized views](https://github.com/0x09/sqlite-statement-vtab).
+- [`github.com/ncruces/go-sqlite3/ext/stats`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/stats)
+  provides [statistics](https://oreilly.com/library/view/sql-in-a/9780596155322/ch04s02.html) functions.
+- [`github.com/ncruces/go-sqlite3/ext/unicode`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/unicode)
+  provides [Unicode aware](https://sqlite.org/src/dir/ext/icu) functions.
+- [`github.com/ncruces/go-sqlite3/ext/uuid`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/uuid)
+  generates [UUIDs](https://en.wikipedia.org/wiki/Universally_unique_identifier).
+- [`github.com/ncruces/go-sqlite3/ext/vec1`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/vec1)
+  provides approximate nearest-neighbor [vector search](https://sqlite.org/vec1/doc/trunk/doc/vec1.md).
+- [`github.com/ncruces/go-sqlite3/ext/zorder`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/zorder)
+  maps multidimensional data to one dimension.
+
+### Packages
+
+These packages may also be useful to work with SQLite:
+
+- [`github.com/ncruces/decimal`](https://pkg.go.dev/github.com/ncruces/decimal)
+  decimal arithmetic.
+- [`github.com/ncruces/julianday`](https://pkg.go.dev/github.com/ncruces/julianday)
+  Julian day math.

ext/array/array.go

@@ -7,8 +7,8 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/ncruces/go-sqlite3"
-	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/internal/util"
 )
 
 // Register registers the array single-argument, table-valued SQL function.
@@ -45,12 +45,14 @@ func (array) Open() (sqlite3.VTabCursor, error) {
 }
 
 type cursor struct {
-	array reflect.Value
-	rowID int
+	value  reflect.Value
+	slice  any
+	rowID  int
+	length int
 }
 
 func (c *cursor) EOF() bool {
-	return c.rowID >= c.array.Len()
+	return c.rowID >= c.length
 }
 
 func (c *cursor) Next() error {
@@ -59,7 +61,8 @@ func (c *cursor) Next() error {
 }
 
 func (c *cursor) RowID() (int64, error) {
-	return int64(c.rowID), nil
+	// One-based RowID for consistency with carray and other tables.
+	return int64(c.rowID) + 1, nil
 }
 
 func (c *cursor) Column(ctx sqlite3.Context, n int) error {
@@ -67,7 +70,22 @@ func (c *cursor) Column(ctx sqlite3.Context, n int) error {
 		return nil
 	}
 
-	v := c.array.Index(c.rowID)
+	switch arr := c.slice.(type) {
+	case []int:
+		ctx.ResultInt(arr[c.rowID])
+		return nil
+	case []int64:
+		ctx.ResultInt64(arr[c.rowID])
+		return nil
+	case []float64:
+		ctx.ResultFloat(arr[c.rowID])
+		return nil
+	case []string:
+		ctx.ResultText(arr[c.rowID])
+		return nil
+	}
+
+	v := c.value.Index(c.rowID)
 	k := v.Kind()
 
 	if k == reflect.Interface {
@@ -109,14 +127,14 @@ func (c *cursor) Column(ctx sqlite3.Context, n int) error {
 	return nil
 }
 
-func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
-	array := reflect.ValueOf(arg[0].Pointer())
-	array, err := indexable(array)
+func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) (err error) {
+	c.slice = arg[0].Pointer()
+	c.value = reflect.ValueOf(c.slice)
+	c.value, err = indexable(c.value)
 	if err != nil {
 		return err
 	}
-
-	c.array = array
+	c.length = c.value.Len()
 	c.rowID = 0
 	return nil
 }

ext/array/array_test.go

@@ -1,22 +1,27 @@
 package array_test
 
 import (
+	"errors"
 	"fmt"
 	"log"
 	"math"
 	"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/internal/testcfg"
-	"github.com/ncruces/go-sqlite3/vfs/memdb"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/driver"
+	"github.com/hanzoai/sqlite3/ext/array"
+	"github.com/hanzoai/sqlite3/ext/rtree"
+	"github.com/hanzoai/sqlite3/internal/testcfg"
+	"github.com/hanzoai/sqlite3/vfs/memdb"
 )
 
 func Example_driver() {
-	db, err := driver.Open("file:/test.db?vfs=memdb", array.Register)
+	db, err := driver.Open("file:/test.db?vfs=memdb", func(c *sqlite3.Conn) error {
+		return errors.Join(
+			array.Register(c),
+			rtree.Register(c))
+	})
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -52,6 +57,7 @@ func Example_driver() {
 
 func Example() {
 	sqlite3.AutoExtension(array.Register)
+	sqlite3.AutoExtension(rtree.Register)
 
 	db, err := sqlite3.Open(":memory:")
 	if err != nil {
@@ -88,15 +94,16 @@ func Example() {
 
 func Test_cursor_Column(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, array.Register)
+	ctx := testcfg.Context(t)
+	db, err := driver.Open(dsn, array.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db.Close()
 
-	rows, err := db.Query(`
+	rows, err := db.QueryContext(ctx, `
 		SELECT rowid, value FROM array(?)`,
 		sqlite3.Pointer(&[...]any{nil, true, 1, uint(2), math.Pi, "text", []byte{1, 2, 3}}))
 	if err != nil {
@@ -129,7 +136,7 @@ func Test_cursor_Column(t *testing.T) {
 func Test_array_errors(t *testing.T) {
 	t.Parallel()
 
-	db, err := sqlite3.Open(":memory:")
+	db, err := sqlite3.OpenContext(testcfg.Context(t), ":memory:")
 	if err != nil {
 		t.Fatal(err)
 	}

ext/blobio/blob.go

@@ -5,8 +5,8 @@ import (
 	"errors"
 	"io"
 
-	"github.com/ncruces/go-sqlite3"
-	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/internal/errutil"
 )
 
 // Register registers the SQL functions:
@@ -44,6 +44,8 @@ func Register(db *sqlite3.Conn) error {
 type OpenCallback func(*sqlite3.Blob, ...sqlite3.Value) error
 
 func readblob(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	_ = arg[5] // bounds check
+
 	blob, err := getAuxBlob(ctx, arg, false)
 	if err != nil {
 		ctx.ResultError(err)
@@ -78,6 +80,8 @@ func readblob(ctx sqlite3.Context, arg ...sqlite3.Value) {
 }
 
 func writeblob(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	_ = arg[5] // bounds check
+
 	blob, err := getAuxBlob(ctx, arg, true)
 	if err != nil {
 		ctx.ResultError(err)
@@ -107,7 +111,7 @@ func writeblob(ctx sqlite3.Context, arg ...sqlite3.Value) {
 
 func openblob(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	if len(arg) < 6 {
-		ctx.ResultError(util.ErrorString("openblob: wrong number of arguments"))
+		ctx.ResultError(errutil.ErrorString("openblob: wrong number of arguments"))
 		return
 	}
 

ext/blobio/blob_test.go

@@ -1,20 +1,20 @@
 package blobio_test
 
 import (
+	"database/sql"
 	"io"
 	"log"
 	"os"
-	"reflect"
+	"slices"
 	"strings"
 	"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"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/driver"
+	"github.com/hanzoai/sqlite3/ext/array"
+	"github.com/hanzoai/sqlite3/ext/blobio"
+	"github.com/hanzoai/sqlite3/internal/testcfg"
+	_ "github.com/hanzoai/sqlite3/vfs/memdb"
 )
 
 func Example() {
@@ -34,7 +34,8 @@ func Example() {
 	const message = "Hello BLOB!"
 
 	// Create the BLOB.
-	r, err := db.Exec(`INSERT INTO test VALUES (?)`, sqlite3.ZeroBlob(len(message)))
+	r, err := db.Exec(`INSERT INTO test VALUES (:data)`,
+		sql.Named("data", sqlite3.ZeroBlob(len(message))))
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -45,15 +46,19 @@ func Example() {
 	}
 
 	// Write the BLOB.
-	_, err = db.Exec(`SELECT writeblob('main', 'test', 'col', ?, 0, ?)`,
-		id, message)
+	_, err = db.Exec(`SELECT writeblob('main', 'test', 'col', :rowid, :offset, :message)`,
+		sql.Named("rowid", id),
+		sql.Named("offset", 0),
+		sql.Named("message", message))
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	// Read the BLOB.
-	_, err = db.Exec(`SELECT readblob('main', 'test', 'col', ?, 0, ?)`,
-		id, sqlite3.Pointer(os.Stdout))
+	_, err = db.Exec(`SELECT readblob('main', 'test', 'col', :rowid, :offset, :writer)`,
+		sql.Named("rowid", id),
+		sql.Named("offset", 0),
+		sql.Named("writer", sqlite3.Pointer(os.Stdout)))
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -64,13 +69,13 @@ func Example() {
 func TestMain(m *testing.M) {
 	sqlite3.AutoExtension(blobio.Register)
 	sqlite3.AutoExtension(array.Register)
-	m.Run()
+	os.Exit(m.Run())
 }
 
 func Test_readblob(t *testing.T) {
 	t.Parallel()
 
-	db, err := sqlite3.Open(":memory:")
+	db, err := sqlite3.OpenContext(testcfg.Context(t), ":memory:")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -138,18 +143,16 @@ func Test_readblob(t *testing.T) {
 				}
 			}
 
-			if stmt.Step() {
-				got := stmt.ColumnText(0)
-				if got != tt.want1 {
-					t.Errorf("got %q", got)
-				}
+			if !stmt.Step() {
+				t.Fatal(stmt.Err())
+			} else if got := stmt.ColumnText(0); got != tt.want1 {
+				t.Errorf("got %q", got)
 			}
 
-			if stmt.Step() {
-				got := stmt.ColumnText(0)
-				if got != tt.want2 {
-					t.Errorf("got %q", got)
-				}
+			if !stmt.Step() {
+				t.Fatal(stmt.Err())
+			} else if got := stmt.ColumnText(0); got != tt.want2 {
+				t.Errorf("got %q", got)
 			}
 
 			err = stmt.Err()
@@ -163,7 +166,7 @@ func Test_readblob(t *testing.T) {
 func Test_writeblob(t *testing.T) {
 	t.Parallel()
 
-	db, err := sqlite3.Open(":memory:")
+	db, err := sqlite3.OpenContext(testcfg.Context(t), ":memory:")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -218,7 +221,7 @@ func Test_writeblob(t *testing.T) {
 func Test_openblob(t *testing.T) {
 	t.Parallel()
 
-	db, err := sqlite3.Open(":memory:")
+	db, err := sqlite3.OpenContext(testcfg.Context(t), ":memory:")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -278,7 +281,7 @@ func Test_openblob(t *testing.T) {
 	}
 
 	want := []string{"\xca\xfe", "\xba\xbe"}
-	if !reflect.DeepEqual(got, want) {
+	if !slices.Equal(got, want) {
 		t.Errorf("got %v, want %v", got, want)
 	}
 }

ext/bloom/bloom.go

@@ -13,8 +13,10 @@ import (
 	"strconv"
 
 	"github.com/dchest/siphash"
-	"github.com/ncruces/go-sqlite3"
-	"github.com/ncruces/go-sqlite3/internal/util"
+
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/internal/errutil"
+	"github.com/hanzoai/sqlite3/util/sql3util"
 )
 
 // Register registers the bloom_filter virtual table:
@@ -33,8 +35,10 @@ type bloom struct {
 	hashes  int
 }
 
+const vtab = `CREATE TABLE x(present, word TEXT HIDDEN NOT NULL PRIMARY KEY) WITHOUT ROWID`
+
 func create(db *sqlite3.Conn, _, schema, table string, arg ...string) (_ *bloom, err error) {
-	t := bloom{
+	b := bloom{
 		db:      db,
 		schema:  schema,
 		storage: table + "_storage",
@@ -47,41 +51,44 @@ func create(db *sqlite3.Conn, _, schema, table string, arg ...string) (_ *bloom,
 			return nil, err
 		}
 		if nelem <= 0 {
-			return nil, util.ErrorString("bloom: number of elements in filter must be positive")
+			return nil, errutil.ErrorString("bloom: number of elements in filter must be positive")
 		}
 	} else {
 		nelem = 100
 	}
 
 	if len(arg) > 1 {
-		t.prob, err = strconv.ParseFloat(arg[1], 64)
-		if err != nil {
-			return nil, err
-		}
-		if t.prob <= 0 || t.prob >= 1 {
-			return nil, util.ErrorString("bloom: probability must be in the range (0,1)")
+		var ok bool
+		b.prob, ok = sql3util.ParseFloat(arg[1])
+		if !ok || b.prob <= 0 || b.prob >= 1 {
+			return nil, errutil.ErrorString("bloom: probability must be in the range (0,1)")
 		}
 	} else {
-		t.prob = 0.01
+		b.prob = 0.01
 	}
 
 	if len(arg) > 2 {
-		t.hashes, err = strconv.Atoi(arg[2])
+		b.hashes, err = strconv.Atoi(arg[2])
 		if err != nil {
 			return nil, err
 		}
-		if t.hashes <= 0 {
-			return nil, util.ErrorString("bloom: number of hash functions must be positive")
+		if b.hashes <= 0 {
+			return nil, errutil.ErrorString("bloom: number of hash functions must be positive")
 		}
 	} else {
-		t.hashes = max(1, numHashes(t.prob))
+		b.hashes = max(1, numHashes(b.prob))
 	}
 
-	t.bytes = numBytes(nelem, t.prob)
+	b.bytes = numBytes(nelem, b.prob)
+
+	err = db.DeclareVTab(vtab)
+	if err != nil {
+		return nil, err
+	}
 
 	err = db.Exec(fmt.Sprintf(
 		`CREATE TABLE %s.%s (data BLOB, p REAL, n INTEGER, m INTEGER, k INTEGER)`,
-		sqlite3.QuoteIdentifier(t.schema), sqlite3.QuoteIdentifier(t.storage)))
+		sqlite3.QuoteIdentifier(b.schema), sqlite3.QuoteIdentifier(b.storage)))
 	if err != nil {
 		return nil, err
 	}
@@ -92,37 +99,31 @@ func create(db *sqlite3.Conn, _, schema, table string, arg ...string) (_ *bloom,
 	err = db.Exec(fmt.Sprintf(
 		`INSERT INTO %s.%s (rowid, data, p, n, m, k)
 		 VALUES (1, zeroblob(%d), %f, %d, %d, %d)`,
-		sqlite3.QuoteIdentifier(t.schema), sqlite3.QuoteIdentifier(t.storage),
-		t.bytes, t.prob, nelem, 8*t.bytes, t.hashes))
+		sqlite3.QuoteIdentifier(b.schema), sqlite3.QuoteIdentifier(b.storage),
+		b.bytes, b.prob, nelem, 8*b.bytes, b.hashes))
 	if err != nil {
+		b.Destroy()
 		return nil, err
 	}
-
-	err = db.DeclareVTab(
-		`CREATE TABLE x(present, word HIDDEN NOT NULL PRIMARY KEY) WITHOUT ROWID`)
-	if err != nil {
-		t.Destroy()
-		return nil, err
-	}
-	return &t, nil
+	return &b, nil
 }
 
 func connect(db *sqlite3.Conn, _, schema, table string, arg ...string) (_ *bloom, err error) {
-	t := bloom{
+	b := bloom{
 		db:      db,
 		schema:  schema,
 		storage: table + "_storage",
 	}
 
-	err = db.DeclareVTab(
-		`CREATE TABLE x(present, word HIDDEN NOT NULL PRIMARY KEY) WITHOUT ROWID`)
+	err = db.DeclareVTab(vtab)
 	if err != nil {
 		return nil, err
 	}
 
-	load, _, err := db.Prepare(fmt.Sprintf(
+	load, _, err := db.PrepareFlags(fmt.Sprintf(
 		`SELECT m/8, p, k FROM %s.%s WHERE rowid = 1`,
-		sqlite3.QuoteIdentifier(t.schema), sqlite3.QuoteIdentifier(t.storage)))
+		sqlite3.QuoteIdentifier(b.schema), sqlite3.QuoteIdentifier(b.storage)),
+		sqlite3.PREPARE_DONT_LOG)
 	if err != nil {
 		return nil, err
 	}
@@ -135,10 +136,10 @@ func connect(db *sqlite3.Conn, _, schema, table string, arg ...string) (_ *bloom
 		return nil, sqlite3.CORRUPT_VTAB
 	}
 
-	t.bytes = load.ColumnInt64(0)
-	t.prob = load.ColumnFloat(1)
-	t.hashes = load.ColumnInt(2)
-	return &t, nil
+	b.bytes = load.ColumnInt64(0)
+	b.prob = load.ColumnFloat(1)
+	b.hashes = load.ColumnInt(2)
+	return &b, nil
 }
 
 func (b *bloom) Destroy() error {
@@ -165,15 +166,16 @@ func (t *bloom) ShadowTables() {
 }
 
 func (t *bloom) Integrity(schema, table string, flags int) error {
-	load, _, err := t.db.Prepare(fmt.Sprintf(
+	load, _, err := t.db.PrepareFlags(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)))
+		sqlite3.QuoteIdentifier(t.schema), sqlite3.QuoteIdentifier(t.storage)),
+		sqlite3.PREPARE_DONT_LOG)
 	if err != nil {
 		return fmt.Errorf("bloom: %v", err) // can't wrap!
 	}
 	defer load.Close()
 
-	err = util.ErrorString("bloom: invalid parameters")
+	err = errutil.ErrorString("bloom: invalid parameters")
 	if !load.Step() {
 		return err
 	}
@@ -198,10 +200,10 @@ func (t *bloom) Integrity(schema, table string, flags int) error {
 }
 
 func (b *bloom) BestIndex(idx *sqlite3.IndexInfo) error {
-	for n, cst := range idx.Constraint {
+	for i, cst := range idx.Constraint {
 		if cst.Usable && cst.Column == 1 &&
 			cst.Op == sqlite3.INDEX_CONSTRAINT_EQ {
-			idx.ConstraintUsage[n].ArgvIndex = 1
+			idx.ConstraintUsage[i].ArgvIndex = 1
 			idx.OrderByConsumed = true
 			idx.EstimatedRows = 1
 			idx.EstimatedCost = float64(b.hashes)
@@ -215,9 +217,9 @@ func (b *bloom) BestIndex(idx *sqlite3.IndexInfo) error {
 func (b *bloom) Update(arg ...sqlite3.Value) (rowid int64, err error) {
 	if arg[0].Type() != sqlite3.NULL {
 		if len(arg) == 1 {
-			return 0, util.ErrorString("bloom: elements cannot be deleted")
+			return 0, errutil.ErrorString("bloom: elements cannot be deleted")
 		}
-		return 0, util.ErrorString("bloom: elements cannot be updated")
+		return 0, errutil.ErrorString("bloom: elements cannot be updated")
 	}
 
 	if arg[2].NoChange() {
@@ -231,7 +233,7 @@ func (b *bloom) Update(arg ...sqlite3.Value) (rowid int64, err error) {
 	}
 	defer f.Close()
 
-	for n := 0; n < b.hashes; n++ {
+	for n := range b.hashes {
 		hash := calcHash(n, blob)
 		hash %= uint64(b.bytes * 8)
 		bitpos := byte(hash % 8)
@@ -267,17 +269,13 @@ func (b *bloom) Open() (sqlite3.VTabCursor, error) {
 
 type cursor struct {
 	*bloom
-	arg *sqlite3.Value
+	arg sqlite3.Value
 	eof bool
 }
 
 func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
-	if len(arg) != 1 {
-		return nil
-	}
-
 	c.eof = false
-	c.arg = &arg[0]
+	c.arg = arg[0]
 	blob := arg[0].RawBlob()
 
 	f, err := c.db.OpenBlob(c.schema, c.storage, "data", 1, false)
@@ -315,7 +313,7 @@ func (c *cursor) Column(ctx sqlite3.Context, n int) error {
 	case 0:
 		ctx.ResultBool(true)
 	case 1:
-		ctx.ResultValue(*c.arg)
+		ctx.ResultValue(c.arg)
 	}
 	return nil
 }

ext/bloom/bloom_test.go

@@ -6,21 +6,20 @@ import (
 	"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"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/ext/bloom"
+	"github.com/hanzoai/sqlite3/internal/testcfg"
 )
 
 func TestMain(m *testing.M) {
 	sqlite3.AutoExtension(bloom.Register)
-	m.Run()
+	os.Exit(m.Run())
 }
 
 func TestRegister(t *testing.T) {
 	t.Parallel()
 
-	db, err := sqlite3.Open(":memory:")
+	db, err := sqlite3.OpenContext(testcfg.Context(t), ":memory:")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -102,7 +101,7 @@ func Test_compatible(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	db, err := sqlite3.Open("file:" + filepath.ToSlash(tmp) + "?nolock=1")
+	db, err := sqlite3.OpenContext(testcfg.Context(t), "file:"+filepath.ToSlash(tmp)+"?nolock=1")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -158,7 +157,7 @@ func Test_compatible(t *testing.T) {
 func Test_errors(t *testing.T) {
 	t.Parallel()
 
-	db, err := sqlite3.Open(":memory:")
+	db, err := sqlite3.OpenContext(testcfg.Context(t), ":memory:")
 	if err != nil {
 		t.Fatal(err)
 	}

ext/closure/closure.go

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

ext/closure/closure_test.go

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

ext/csv/arg.go

@@ -4,8 +4,7 @@ import (
 	"fmt"
 	"strconv"
 
-	"github.com/ncruces/go-sqlite3/internal/util"
-	"github.com/ncruces/go-sqlite3/util/vtabutil"
+	"github.com/hanzoai/sqlite3/util/sql3util"
 )
 
 func uintArg(key, val string) (int, error) {
@@ -20,7 +19,7 @@ func boolArg(key, val string) (bool, error) {
 	if val == "" {
 		return true, nil
 	}
-	b, ok := util.ParseBool(val)
+	b, ok := sql3util.ParseBool(val)
 	if ok {
 		return b, nil
 	}
@@ -28,7 +27,7 @@ func boolArg(key, val string) (bool, error) {
 }
 
 func runeArg(key, val string) (rune, error) {
-	r, _, tail, err := strconv.UnquoteChar(vtabutil.Unquote(val), 0)
+	r, _, tail, err := strconv.UnquoteChar(sql3util.Unquote(val), 0)
 	if tail != "" || err != nil {
 		return 0, fmt.Errorf("csv: invalid %q parameter: %s", key, val)
 	}

ext/csv/arg_test.go

@@ -3,7 +3,7 @@ package csv
 import (
 	"testing"
 
-	"github.com/ncruces/go-sqlite3/util/vtabutil"
+	"github.com/hanzoai/sqlite3/util/sql3util"
 )
 
 func Test_uintArg(t *testing.T) {
@@ -24,7 +24,7 @@ func Test_uintArg(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.arg, func(t *testing.T) {
-			key, val := vtabutil.NamedArg(tt.arg)
+			key, val := sql3util.NamedArg(tt.arg)
 			if key != tt.key {
 				t.Errorf("NamedArg() %v, want err %v", key, tt.key)
 			}
@@ -62,7 +62,7 @@ func Test_boolArg(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.arg, func(t *testing.T) {
-			key, val := vtabutil.NamedArg(tt.arg)
+			key, val := sql3util.NamedArg(tt.arg)
 			if key != tt.key {
 				t.Errorf("NamedArg() %v, want err %v", key, tt.key)
 			}
@@ -96,7 +96,7 @@ func Test_runeArg(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.arg, func(t *testing.T) {
-			key, val := vtabutil.NamedArg(tt.arg)
+			key, val := sql3util.NamedArg(tt.arg)
 			if key != tt.key {
 				t.Errorf("NamedArg() %v, want err %v", key, tt.key)
 			}

ext/csv/csv.go

@@ -15,10 +15,11 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/ncruces/go-sqlite3"
-	"github.com/ncruces/go-sqlite3/internal/util"
-	"github.com/ncruces/go-sqlite3/util/osutil"
-	"github.com/ncruces/go-sqlite3/util/vtabutil"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/internal/errutil"
+	"github.com/hanzoai/sqlite3/internal/util"
+	"github.com/hanzoai/sqlite3/util/osutil"
+	"github.com/hanzoai/sqlite3/util/sql3util"
 )
 
 // Register registers the CSV virtual table.
@@ -40,21 +41,21 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
 			comma    rune = ','
 			comment  rune
 
-			done = map[string]struct{}{}
+			done = util.Set[string]{}
 		)
 
 		for _, arg := range arg {
-			key, val := vtabutil.NamedArg(arg)
-			if _, ok := done[key]; ok {
+			key, val := sql3util.NamedArg(arg)
+			if done.Contains(key) {
 				return nil, fmt.Errorf("csv: more than one %q parameter", key)
 			}
 			switch key {
 			case "filename":
-				filename = vtabutil.Unquote(val)
+				filename = sql3util.Unquote(val)
 			case "data":
-				data = vtabutil.Unquote(val)
+				data = sql3util.Unquote(val)
 			case "schema":
-				schema = vtabutil.Unquote(val)
+				schema = sql3util.Unquote(val)
 			case "header":
 				header, err = boolArg(key, val)
 			case "columns":
@@ -69,14 +70,14 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
 			if err != nil {
 				return nil, err
 			}
-			done[key] = struct{}{}
+			done.Add(key)
 		}
 
 		if (filename == "") == (data == "") {
-			return nil, util.ErrorString(`csv: must specify either "filename" or "data" but not both`)
+			return nil, errutil.ErrorString(`csv: must specify either "filename" or "data" but not both`)
 		}
 
-		table := &table{
+		t := &table{
 			fsys:    fsys,
 			name:    filename,
 			data:    data,
@@ -85,10 +86,11 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
 			header:  header,
 		}
 
-		if schema == "" {
+		hadSchema := schema != ""
+		if !hadSchema {
 			var row []string
 			if header || columns < 0 {
-				csv, c, err := table.newReader()
+				csv, c, err := t.newReader()
 				defer c.Close()
 				if err != nil {
 					return nil, err
@@ -99,23 +101,18 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
 				}
 			}
 			schema = getSchema(header, columns, row)
-		} else {
-			defer func() {
-				if err == nil {
-					table.typs, err = getColumnAffinities(schema)
-				}
-			}()
 		}
-
 		err = db.DeclareVTab(schema)
+		if err == nil {
+			err = db.VTabConfig(sqlite3.VTAB_DIRECTONLY)
+		}
+		if err == nil && hadSchema {
+			t.typs, err = getColumnAffinities(schema)
+		}
 		if err != nil {
 			return nil, err
 		}
-		err = db.VTabConfig(sqlite3.VTAB_DIRECTONLY)
-		if err != nil {
-			return nil, err
-		}
-		return table, nil
+		return t, nil
 	}
 
 	return sqlite3.CreateModule(db, "csv", declare, declare)
@@ -125,7 +122,7 @@ type table struct {
 	fsys    fs.FS
 	name    string
 	data    string
-	typs    []affinity
+	typs    []sql3util.Affinity
 	comma   rune
 	comment rune
 	header  bool
@@ -216,7 +213,10 @@ func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
 		return err
 	}
 	if c.table.header {
-		c.Next() // skip header
+		err = c.Next() // skip header
+		if err != nil {
+			return err
+		}
 	}
 	c.rowID = 0
 	return c.Next()
@@ -241,31 +241,27 @@ func (c *cursor) RowID() (int64, error) {
 
 func (c *cursor) Column(ctx sqlite3.Context, col int) error {
 	if col < len(c.row) {
-		typ := text
+		typ := sql3util.TEXT
 		if col < len(c.table.typs) {
 			typ = c.table.typs[col]
 		}
 
 		txt := c.row[col]
-		if txt == "" && typ != text {
+		if txt == "" && typ != sql3util.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
-				}
+		case sql3util.NUMERIC, sql3util.INTEGER:
+			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
-				}
+		case sql3util.REAL:
+			if f, ok := sql3util.ParseFloat(txt); ok {
+				ctx.ResultFloat(f)
+				return nil
 			}
 			fallthrough
 		default:

ext/csv/csv_test.go

@@ -3,12 +3,12 @@ package csv_test
 import (
 	"fmt"
 	"log"
+	"os"
 	"testing"
 
-	"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"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/ext/csv"
+	"github.com/hanzoai/sqlite3/internal/testcfg"
 )
 
 func Example() {
@@ -56,13 +56,13 @@ func Example() {
 
 func TestMain(m *testing.M) {
 	sqlite3.AutoExtension(csv.Register)
-	m.Run()
+	os.Exit(m.Run())
 }
 
 func TestRegister(t *testing.T) {
 	t.Parallel()
 
-	db, err := sqlite3.Open(":memory:")
+	db, err := sqlite3.OpenContext(testcfg.Context(t), ":memory:")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -124,7 +124,7 @@ Robert	"Griesemer"	"gri"`
 func TestAffinity(t *testing.T) {
 	t.Parallel()
 
-	db, err := sqlite3.Open(":memory:")
+	db, err := sqlite3.OpenContext(testcfg.Context(t), ":memory:")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -146,27 +146,28 @@ func TestAffinity(t *testing.T) {
 	}
 	defer stmt.Close()
 
-	if stmt.Step() {
-		if got := stmt.ColumnText(0); got != "1" {
-			t.Errorf("got %q want 1", got)
-		}
+	if !stmt.Step() {
+		t.Fatal(stmt.Err())
+	} else 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() {
+		t.Fatal(stmt.Err())
+	} else 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)
-		}
+
+	if !stmt.Step() {
+		t.Fatal(stmt.Err())
+	} else 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:")
+	db, err := sqlite3.OpenContext(testcfg.Context(t), ":memory:")
 	if err != nil {
 		t.Fatal(err)
 	}

ext/csv/schema.go

@@ -4,36 +4,36 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/ncruces/go-sqlite3"
+	"github.com/hanzoai/sqlite3"
 )
 
 func getSchema(header bool, columns int, row []string) string {
 	var sep string
-	var str strings.Builder
-	str.WriteString("CREATE TABLE x(")
+	var buf strings.Builder
+	buf.WriteString("CREATE TABLE x(")
 
 	if 0 <= columns && columns < len(row) {
 		row = row[:columns]
 	}
 	for i, f := range row {
-		str.WriteString(sep)
+		buf.WriteString(sep)
 		if header && f != "" {
-			str.WriteString(sqlite3.QuoteIdentifier(f))
+			buf.WriteString(sqlite3.QuoteIdentifier(f))
 		} else {
-			str.WriteString("c")
-			str.WriteString(strconv.Itoa(i + 1))
+			buf.WriteString("c")
+			buf.WriteString(strconv.Itoa(i + 1))
 		}
-		str.WriteString(" TEXT")
+		buf.WriteString(" TEXT")
 		sep = ","
 	}
 	for i := len(row); i < columns; i++ {
-		str.WriteString(sep)
-		str.WriteString("c")
-		str.WriteString(strconv.Itoa(i + 1))
-		str.WriteString(" TEXT")
+		buf.WriteString(sep)
+		buf.WriteString("c")
+		buf.WriteString(strconv.Itoa(i + 1))
+		buf.WriteString(" TEXT")
 		sep = ","
 	}
-	str.WriteByte(')')
+	buf.WriteByte(')')
 
-	return str.String()
+	return buf.String()
 }

ext/csv/types.go

@@ -1,51 +1,17 @@
 package csv
 
-import (
-	"strings"
+import "github.com/hanzoai/sqlite3/util/sql3util"
 
-	"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)
+func getColumnAffinities(schema string) ([]sql3util.Affinity, error) {
+	tab, err := sql3util.ParseTable(schema)
 	if err != nil {
 		return nil, err
 	}
 
-	types := make([]affinity, len(tab.Columns))
-	for i, col := range tab.Columns {
-		types[i] = getAffinity(col.Type)
+	columns := tab.Columns
+	types := make([]sql3util.Affinity, len(columns))
+	for i, col := range columns {
+		types[i] = sql3util.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

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

ext/fileio/coro.go

@@ -1,70 +0,0 @@
-//go:build !(go1.23 || goexperiment.rangefunc) || vet
-
-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

@@ -9,7 +9,7 @@ import (
 	"io/fs"
 	"os"
 
-	"github.com/ncruces/go-sqlite3"
+	"github.com/hanzoai/sqlite3"
 )
 
 // Register registers SQL functions readfile, writefile, lsmode,
@@ -18,7 +18,7 @@ func Register(db *sqlite3.Conn) error {
 	return RegisterFS(db, nil)
 }
 
-// Register registers SQL functions readfile, lsmode,
+// RegisterFS 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) error {
@@ -30,8 +30,10 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
 		db.CreateFunction("readfile", 1, sqlite3.DIRECTONLY, readfile(fsys)),
 		db.CreateFunction("lsmode", 1, sqlite3.DETERMINISTIC, lsmode),
 		sqlite3.CreateModule(db, "fsdir", nil, func(db *sqlite3.Conn, _, _, _ string, _ ...string) (fsdir, error) {
-			err := db.DeclareVTab(`CREATE TABLE x(name,mode,mtime TIMESTAMP,data,path HIDDEN,dir HIDDEN)`)
-			db.VTabConfig(sqlite3.VTAB_DIRECTONLY)
+			err := db.DeclareVTab(`CREATE TABLE x(name TEXT,mode INT,mtime TIMESTAMP,data BLOB,level INT,path HIDDEN,dir HIDDEN)`)
+			if err == nil {
+				err = db.VTabConfig(sqlite3.VTAB_DIRECTONLY)
+			}
 			return fsdir{fsys}, err
 		}))
 }
@@ -40,7 +42,7 @@ func lsmode(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	ctx.ResultText(fs.FileMode(arg[0].Int()).String())
 }
 
-func readfile(fsys fs.FS) func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+func readfile(fsys fs.FS) sqlite3.ScalarFunction {
 	return func(ctx sqlite3.Context, arg ...sqlite3.Value) {
 		var err error
 		var data []byte

ext/fileio/fileio_test.go

@@ -7,19 +7,19 @@ import (
 	"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"
-	"github.com/ncruces/go-sqlite3/vfs/memdb"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/driver"
+	"github.com/hanzoai/sqlite3/ext/fileio"
+	"github.com/hanzoai/sqlite3/internal/testcfg"
+	"github.com/hanzoai/sqlite3/vfs/memdb"
 )
 
 func Test_lsmode(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, fileio.Register)
+	ctx := testcfg.Context(t)
+	db, err := driver.Open(dsn, fileio.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -36,7 +36,7 @@ func Test_lsmode(t *testing.T) {
 	}
 
 	var mode string
-	err = db.QueryRow(`SELECT lsmode(?)`, s.Mode()).Scan(&mode)
+	err = db.QueryRowContext(ctx, `SELECT lsmode(?)`, s.Mode()).Scan(&mode)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -53,9 +53,10 @@ func Test_readfile(t *testing.T) {
 
 	for _, fsys := range []fs.FS{nil, os.DirFS(".")} {
 		t.Run("", func(t *testing.T) {
-			tmp := memdb.TestDB(t)
+			dsn := memdb.TestDB(t)
 
-			db, err := driver.Open(tmp, func(c *sqlite3.Conn) error {
+			ctx := testcfg.Context(t)
+			db, err := driver.Open(dsn, func(c *sqlite3.Conn) error {
 				fileio.RegisterFS(c, fsys)
 				return nil
 			})
@@ -64,7 +65,7 @@ func Test_readfile(t *testing.T) {
 			}
 			defer db.Close()
 
-			rows, err := db.Query(`SELECT readfile('fileio_test.go')`)
+			rows, err := db.QueryContext(ctx, `SELECT readfile('fileio_test.go')`)
 			if err != nil {
 				t.Fatal(err)
 			}

ext/fileio/fsdir.go

@@ -2,21 +2,36 @@ package fileio
 
 import (
 	"io/fs"
+	"iter"
 	"os"
 	"path"
 	"path/filepath"
 	"strings"
 
-	"github.com/ncruces/go-sqlite3"
+	"github.com/hanzoai/sqlite3"
+)
+
+const (
+	_COL_NAME = iota
+	_COL_MODE
+	_COL_MTIME
+	_COL_DATA
+	_COL_LEVEL
+	_COL_ROOT
+	_COL_BASE
 )
 
 type fsdir struct{ fsys fs.FS }
 
 func (d fsdir) BestIndex(idx *sqlite3.IndexInfo) error {
-	var root, base bool
+	var levelOp sqlite3.IndexConstraintOp
+	var root bool
+	level := -1
+	base := -1
+
 	for i, cst := range idx.Constraint {
 		switch cst.Column {
-		case 4: // root
+		case _COL_ROOT:
 			if !cst.Usable || cst.Op != sqlite3.INDEX_CONSTRAINT_EQ {
 				return sqlite3.CONSTRAINT
 			}
@@ -25,24 +40,48 @@ func (d fsdir) BestIndex(idx *sqlite3.IndexInfo) error {
 				ArgvIndex: 1,
 			}
 			root = true
-		case 5: // base
+		case _COL_BASE:
 			if !cst.Usable || cst.Op != sqlite3.INDEX_CONSTRAINT_EQ {
 				return sqlite3.CONSTRAINT
 			}
-			idx.ConstraintUsage[i] = sqlite3.IndexConstraintUsage{
-				Omit:      true,
-				ArgvIndex: 2,
+			base = i
+		case _COL_LEVEL:
+			if !cst.Usable {
+				break
+			}
+			switch cst.Op {
+			case sqlite3.INDEX_CONSTRAINT_EQ, sqlite3.INDEX_CONSTRAINT_LE, sqlite3.INDEX_CONSTRAINT_LT:
+				levelOp = cst.Op
+				level = i
 			}
-			base = true
 		}
 	}
 	if !root {
 		return sqlite3.CONSTRAINT
 	}
-	if base {
-		idx.EstimatedCost = 10
-	} else {
-		idx.EstimatedCost = 100
+
+	args := 2
+	idx.IdxNum = 0
+	idx.EstimatedCost = 1e9
+	if base >= 0 {
+		idx.IdxNum |= 1
+		idx.EstimatedCost /= 1e4
+		idx.ConstraintUsage[base] = sqlite3.IndexConstraintUsage{
+			Omit:      true,
+			ArgvIndex: args,
+		}
+		args++
+	}
+	if level >= 0 {
+		idx.EstimatedCost /= 1e4
+		idx.IdxNum |= (args - 1) << 1
+		if levelOp == sqlite3.INDEX_CONSTRAINT_LT {
+			idx.IdxNum |= 1 << 3
+		}
+		idx.ConstraintUsage[level] = sqlite3.IndexConstraintUsage{
+			Omit:      levelOp != sqlite3.INDEX_CONSTRAINT_EQ,
+			ArgvIndex: args,
+		}
 	}
 	return nil
 }
@@ -53,23 +92,25 @@ func (d fsdir) Open() (sqlite3.VTabCursor, error) {
 
 type cursor struct {
 	fsdir
-	base   string
-	resume resume
-	cancel func()
-	curr   entry
-	eof    bool
-	rowID  int64
+	base     string
+	next     func() (entry, bool)
+	stop     func()
+	curr     entry
+	eof      bool
+	rowID    int64
+	maxLevel int
 }
 
 type entry struct {
 	fs.DirEntry
-	err  error
-	path string
+	err   error
+	path  string
+	level int
 }
 
 func (c *cursor) Close() error {
-	if c.cancel != nil {
-		c.cancel()
+	if c.stop != nil {
+		c.stop()
 	}
 	return nil
 }
@@ -80,26 +121,54 @@ func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
 	}
 
 	root := arg[0].Text()
-	if len(arg) > 1 {
-		base := arg[1].Text()
+	if i := idxNum & 1; i > 0 {
+		base := arg[i].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)
 		}
+		root = base + root
 		c.base = base
 	}
+	if i := idxNum >> 1; i > 0 {
+		c.maxLevel = arg[i&3].Int() - i>>2
+	}
 
-	c.resume, c.cancel = pull(c, root)
+	c.next, c.stop = iter.Pull(func(yield func(entry) bool) {
+		var stack []string
+		walkDir := func(p string, d fs.DirEntry, err error) error {
+			level := len(stack)
+			for level > 1 && !strings.HasPrefix(c.dir(p), stack[level-1]) {
+				level--
+			}
+			stack = stack[:level]
+			level++
+
+			if !yield(entry{d, err, p, level}) {
+				return fs.SkipAll
+			}
+			if d != nil && d.IsDir() {
+				if 0 < c.maxLevel && c.maxLevel <= level {
+					return fs.SkipDir
+				}
+				stack = append(stack, p)
+			}
+			return nil
+		}
+		if c.fsys != nil {
+			fs.WalkDir(c.fsys, root, walkDir)
+		} else {
+			filepath.WalkDir(root, walkDir)
+		}
+	})
 	c.eof = false
 	c.rowID = 0
 	return c.Next()
 }
 
 func (c *cursor) Next() error {
-	curr, ok := next(c)
+	curr, ok := c.next()
 	c.curr = curr
 	c.eof = !ok
 	c.rowID++
@@ -116,25 +185,25 @@ func (c *cursor) RowID() (int64, error) {
 
 func (c *cursor) Column(ctx sqlite3.Context, n int) error {
 	switch n {
-	case 0: // name
+	case _COL_NAME:
 		name := strings.TrimPrefix(c.curr.path, c.base)
 		ctx.ResultText(name)
 
-	case 1: // mode
+	case _COL_MODE:
 		i, err := c.curr.Info()
 		if err != nil {
 			return err
 		}
 		ctx.ResultInt64(int64(i.Mode()))
 
-	case 2: // mtime
+	case _COL_MTIME:
 		i, err := c.curr.Info()
 		if err != nil {
 			return err
 		}
 		ctx.ResultTime(i.ModTime(), sqlite3.TimeFormatUnixFrac)
 
-	case 3: // data
+	case _COL_DATA:
 		switch typ := c.curr.Type(); {
 		case typ.IsRegular():
 			var data []byte
@@ -156,6 +225,22 @@ func (c *cursor) Column(ctx sqlite3.Context, n int) error {
 			}
 			ctx.ResultText(t)
 		}
+
+	case _COL_LEVEL:
+		ctx.ResultInt(c.curr.level)
 	}
 	return nil
 }
+
+func (c *cursor) dir(p string) string {
+	var dir string
+	if c.fsys != nil {
+		dir, _ = path.Split(p)
+	} else {
+		dir, _ = filepath.Split(p)
+	}
+	if dir == "" {
+		dir = "."
+	}
+	return dir
+}

ext/fileio/fsdir_coro.go

@@ -1,29 +0,0 @@
-//go:build !(go1.23 || goexperiment.rangefunc) || vet
-
-package fileio
-
-import (
-	"io/fs"
-	"path/filepath"
-)
-
-type resume = func(struct{}) (entry, bool)
-
-func next(c *cursor) (entry, bool) {
-	return c.resume(struct{}{})
-}
-
-func pull(c *cursor, root string) (resume, func()) {
-	return coroNew(func(_ struct{}, yield func(entry) struct{}) entry {
-		walkDir := func(path string, d fs.DirEntry, err error) error {
-			yield(entry{d, err, path})
-			return nil
-		}
-		if c.fsys != nil {
-			fs.WalkDir(c.fsys, root, walkDir)
-		} else {
-			filepath.WalkDir(root, walkDir)
-		}
-		return entry{}
-	})
-}

ext/fileio/fsdir_iter.go

@@ -1,31 +0,0 @@
-//go:build (go1.23 || goexperiment.rangefunc) && !vet
-
-package fileio
-
-import (
-	"io/fs"
-	"iter"
-	"path/filepath"
-)
-
-type resume = func() (entry, bool)
-
-func next(c *cursor) (entry, bool) {
-	return c.resume()
-}
-
-func pull(c *cursor, root string) (resume, func()) {
-	return iter.Pull(func(yield func(entry) bool) {
-		walkDir := func(path string, d fs.DirEntry, err error) error {
-			if yield(entry{d, err, path}) {
-				return nil
-			}
-			return fs.SkipAll
-		}
-		if c.fsys != nil {
-			fs.WalkDir(c.fsys, root, walkDir)
-		} else {
-			filepath.WalkDir(root, walkDir)
-		}
-	})
-}

ext/fileio/fsdir_test.go

@@ -8,12 +8,11 @@ import (
 	"testing"
 	"time"
 
-	"github.com/ncruces/go-sqlite3"
-	"github.com/ncruces/go-sqlite3/driver"
-	_ "github.com/ncruces/go-sqlite3/embed"
-	"github.com/ncruces/go-sqlite3/ext/fileio"
-	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
-	"github.com/ncruces/go-sqlite3/vfs/memdb"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/driver"
+	"github.com/hanzoai/sqlite3/ext/fileio"
+	"github.com/hanzoai/sqlite3/internal/testcfg"
+	"github.com/hanzoai/sqlite3/vfs/memdb"
 )
 
 func Test_fsdir(t *testing.T) {
@@ -21,9 +20,10 @@ func Test_fsdir(t *testing.T) {
 
 	for _, fsys := range []fs.FS{nil, os.DirFS(".")} {
 		t.Run("", func(t *testing.T) {
-			tmp := memdb.TestDB(t)
+			dsn := memdb.TestDB(t)
 
-			db, err := driver.Open(tmp, func(c *sqlite3.Conn) error {
+			ctx := testcfg.Context(t)
+			db, err := driver.Open(dsn, func(c *sqlite3.Conn) error {
 				fileio.RegisterFS(c, fsys)
 				return nil
 			})
@@ -32,7 +32,7 @@ func Test_fsdir(t *testing.T) {
 			}
 			defer db.Close()
 
-			rows, err := db.Query(`SELECT * FROM fsdir('.', '.')`)
+			rows, err := db.QueryContext(ctx, `SELECT * FROM fsdir('.') WHERE level <= 2`)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -42,7 +42,8 @@ func Test_fsdir(t *testing.T) {
 				var mode fs.FileMode
 				var mtime time.Time
 				var data sql.RawBytes
-				err := rows.Scan(&name, &mode, sqlite3.TimeFormatUnixFrac.Scanner(&mtime), &data)
+				var level int
+				err := rows.Scan(&name, &mode, sqlite3.TimeFormatUnixFrac.Scanner(&mtime), &data, &level)
 				if err != nil {
 					t.Fatal(err)
 				}
@@ -57,6 +58,9 @@ func Test_fsdir(t *testing.T) {
 						t.Errorf("got: %s", data[:min(64, len(data))])
 					}
 				}
+				if level > 2 {
+					t.Errorf("got: %v", level)
+				}
 			}
 		})
 	}
@@ -65,7 +69,7 @@ func Test_fsdir(t *testing.T) {
 func Test_fsdir_errors(t *testing.T) {
 	t.Parallel()
 
-	db, err := sqlite3.Open(":memory:")
+	db, err := sqlite3.OpenContext(testcfg.Context(t), ":memory:")
 	if err != nil {
 		t.Fatal(err)
 	}

ext/fileio/write.go

@@ -8,14 +8,14 @@ import (
 	"path/filepath"
 	"time"
 
-	"github.com/ncruces/go-sqlite3"
-	"github.com/ncruces/go-sqlite3/internal/util"
-	"github.com/ncruces/go-sqlite3/util/fsutil"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/internal/errutil"
+	"github.com/hanzoai/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"))
+		ctx.ResultError(errutil.ErrorString("writefile: wrong number of arguments"))
 		return
 	}
 

ext/fileio/write_test.go

@@ -1,3 +1,5 @@
+//go:build !js
+
 package fileio
 
 import (
@@ -7,17 +9,17 @@ import (
 	"testing"
 	"time"
 
-	"github.com/ncruces/go-sqlite3/driver"
-	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
-	"github.com/ncruces/go-sqlite3/vfs/memdb"
+	"github.com/hanzoai/sqlite3/driver"
+	"github.com/hanzoai/sqlite3/internal/testcfg"
+	"github.com/hanzoai/sqlite3/vfs/memdb"
 )
 
 func Test_writefile(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, Register)
+	ctx := testcfg.Context(t)
+	db, err := driver.Open(dsn, Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -30,22 +32,22 @@ func Test_writefile(t *testing.T) {
 	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)
+	_, err = db.ExecContext(ctx, `SELECT writefile(?, 'Hello world!')`, file)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	_, err = db.Exec(`SELECT writefile(?, ?, ?)`, link, "test.txt", fs.ModeSymlink)
+	_, err = db.ExecContext(ctx, `SELECT writefile(?, ?, ?)`, link, "test.txt", fs.ModeSymlink)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	_, err = db.Exec(`SELECT writefile(?, ?, ?, ?)`, dir, nil, 0040700, twosday.Unix())
+	_, err = db.ExecContext(ctx, `SELECT writefile(?, ?, ?, ?)`, dir, nil, 0040700, twosday.Unix())
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	rows, err := db.Query(`SELECT * FROM fsdir('.', ?)`, dir)
+	rows, err := db.QueryContext(ctx, `SELECT * FROM fsdir('.', ?)`, dir)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -55,7 +57,8 @@ func Test_writefile(t *testing.T) {
 		var mode fs.FileMode
 		var mtime time.Time
 		var data sql.NullString
-		err := rows.Scan(&name, &mode, &mtime, &data)
+		var level int
+		err := rows.Scan(&name, &mode, &mtime, &data, &level)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -70,19 +73,19 @@ func Test_writefile(t *testing.T) {
 		}
 	}
 
-	_, err = db.Exec(`SELECT writefile(?, 'Hello world!')`, nest)
+	_, err = db.ExecContext(ctx, `SELECT writefile(?, 'Hello world!')`, nest)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	_, err = db.Exec(`SELECT writefile(?, ?, ?)`, sock, nil, fs.ModeSocket)
+	_, err = db.ExecContext(ctx, `SELECT writefile(?, ?, ?)`, sock, nil, fs.ModeSocket)
 	if err == nil {
 		t.Fatal("want error")
 	} else {
 		t.Log(err)
 	}
 
-	_, err = db.Exec(`SELECT writefile()`)
+	_, err = db.ExecContext(ctx, `SELECT writefile()`)
 	if err == nil {
 		t.Fatal("want error")
 	} else {

ext/fts5/fts5.go

@@ -0,0 +1,14 @@
+// Package fts5 provides the fts5 extension.
+//
+// https://sqlite.org/fts5.html
+package fts5
+
+import (
+	"github.com/hanzoai/sqlite3"
+	"github.com/ncruces/go-sqlite3-wasm/v3/fts5"
+)
+
+// Register registers the fts5 extension.
+func Register(db *sqlite3.Conn) error {
+	return sqlite3.ExtensionInit(db, fts5.New, fts5.DylinkInfo)
+}

ext/fts5/fts5_test.go

@@ -0,0 +1,37 @@
+package fts5_test
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/hanzoai/sqlite3/driver"
+	"github.com/hanzoai/sqlite3/ext/fts5"
+	_ "github.com/hanzoai/sqlite3/vfs/memdb"
+)
+
+func Example() {
+	db, err := driver.Open("file:/test.db?vfs=memdb", fts5.Register)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec(`
+		CREATE VIRTUAL TABLE docs USING fts5(title, body);
+		INSERT INTO docs(title, body) VALUES 
+			('Go Programming', 'An intensive guide to Go routines.'),
+			('SQLite Tutorial', 'Learn how to use virtual tables efficiently.');
+	`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	var title string
+	err = db.QueryRow("SELECT title FROM docs WHERE docs MATCH 'Go AND routines'").Scan(&title)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Println(title)
+	// Output: Go Programming
+}

ext/hash/blake2.go

@@ -3,8 +3,8 @@ package hash
 import (
 	"crypto"
 
-	"github.com/ncruces/go-sqlite3"
-	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/internal/errutil"
 )
 
 func blake2sFunc(ctx sqlite3.Context, arg ...sqlite3.Value) {
@@ -25,6 +25,6 @@ func blake2bFunc(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	case 512:
 		hashFunc(ctx, arg[0], crypto.BLAKE2b_512)
 	default:
-		ctx.ResultError(util.ErrorString("blake2b: size must be 256, 384, 512"))
+		ctx.ResultError(errutil.ErrorString("blake2b: size must be 256, 384, 512"))
 	}
 }

ext/hash/hash.go

@@ -23,15 +23,15 @@ import (
 	"crypto"
 	"errors"
 
-	"github.com/ncruces/go-sqlite3"
-	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/internal/errutil"
 )
 
 // Register registers cryptographic hash functions for a database connection.
 func Register(db *sqlite3.Conn) error {
-	flags := sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
+	const flags = sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
 
-	var errs util.ErrorJoiner
+	var errs errutil.ErrorJoiner
 	if crypto.MD4.Available() {
 		errs.Join(
 			db.CreateFunction("md4", 1, flags, md4Func))

ext/hash/hash_test.go

@@ -4,23 +4,23 @@ import (
 	_ "crypto/md5"
 	_ "crypto/sha1"
 	_ "crypto/sha256"
+	_ "crypto/sha3"
 	_ "crypto/sha512"
 	"testing"
 
-	"github.com/ncruces/go-sqlite3/driver"
-	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
-	"github.com/ncruces/go-sqlite3/vfs/memdb"
 	_ "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"
+
+	"github.com/hanzoai/sqlite3/driver"
+	"github.com/hanzoai/sqlite3/internal/testcfg"
+	"github.com/hanzoai/sqlite3/vfs/memdb"
 )
 
 func TestRegister(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
 	tests := []struct {
 		name string
@@ -54,7 +54,8 @@ func TestRegister(t *testing.T) {
 		{"blake2b('', 256)", "0E5751C026E543B2E8AB2EB06099DAA1D1E5DF47778F7787FAAB45CDF12FE3A8"},
 	}
 
-	db, err := driver.Open(tmp, Register)
+	ctx := testcfg.Context(t)
+	db, err := driver.Open(dsn, Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -64,7 +65,7 @@ func TestRegister(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			var hash string
 
-			err = db.QueryRow(`SELECT hex(` + tt.name + `)`).Scan(&hash)
+			err = db.QueryRowContext(ctx, `SELECT hex(`+tt.name+`)`).Scan(&hash)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -75,22 +76,22 @@ func TestRegister(t *testing.T) {
 		})
 	}
 
-	_, err = db.Exec(`SELECT sha256('', 255)`)
+	_, err = db.ExecContext(ctx, `SELECT sha256('', 255)`)
 	if err == nil {
 		t.Error("want error")
 	}
 
-	_, err = db.Exec(`SELECT sha512('', 255)`)
+	_, err = db.ExecContext(ctx, `SELECT sha512('', 255)`)
 	if err == nil {
 		t.Error("want error")
 	}
 
-	_, err = db.Exec(`SELECT sha3('', 255)`)
+	_, err = db.ExecContext(ctx, `SELECT sha3('', 255)`)
 	if err == nil {
 		t.Error("want error")
 	}
 
-	_, err = db.Exec(`SELECT blake2b('', 255)`)
+	_, err = db.ExecContext(ctx, `SELECT blake2b('', 255)`)
 	if err == nil {
 		t.Error("want error")
 	}

ext/hash/sha2.go

@@ -3,8 +3,8 @@ package hash
 import (
 	"crypto"
 
-	"github.com/ncruces/go-sqlite3"
-	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/internal/errutil"
 )
 
 func sha224Func(ctx sqlite3.Context, arg ...sqlite3.Value) {
@@ -27,7 +27,7 @@ func sha256Func(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	case 256:
 		hashFunc(ctx, arg[0], crypto.SHA256)
 	default:
-		ctx.ResultError(util.ErrorString("sha256: size must be 224, 256"))
+		ctx.ResultError(errutil.ErrorString("sha256: size must be 224, 256"))
 	}
 }
 
@@ -47,7 +47,7 @@ func sha512Func(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	case 512:
 		hashFunc(ctx, arg[0], crypto.SHA512)
 	default:
-		ctx.ResultError(util.ErrorString("sha512: size must be 224, 256, 384, 512"))
+		ctx.ResultError(errutil.ErrorString("sha512: size must be 224, 256, 384, 512"))
 	}
 
 }

ext/hash/sha3.go

@@ -3,8 +3,8 @@ package hash
 import (
 	"crypto"
 
-	"github.com/ncruces/go-sqlite3"
-	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/internal/errutil"
 )
 
 func sha3Func(ctx sqlite3.Context, arg ...sqlite3.Value) {
@@ -23,6 +23,6 @@ func sha3Func(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	case 512:
 		hashFunc(ctx, arg[0], crypto.SHA3_512)
 	default:
-		ctx.ResultError(util.ErrorString("sha3: size must be 224, 256, 384, 512"))
+		ctx.ResultError(errutil.ErrorString("sha3: size must be 224, 256, 384, 512"))
 	}
 }

ext/ipaddr/ipaddr.go

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

ext/ipaddr/ipaddr_test.go

@@ -0,0 +1,88 @@
+package ipaddr_test
+
+import (
+	"testing"
+
+	"github.com/hanzoai/sqlite3/driver"
+	"github.com/hanzoai/sqlite3/ext/ipaddr"
+	"github.com/hanzoai/sqlite3/internal/testcfg"
+	"github.com/hanzoai/sqlite3/vfs/memdb"
+)
+
+func TestRegister(t *testing.T) {
+	t.Parallel()
+	dsn := memdb.TestDB(t)
+
+	ctx := testcfg.Context(t)
+	db, err := driver.Open(dsn, ipaddr.Register)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	var got string
+
+	err = db.QueryRowContext(ctx, `SELECT ipfamily('::1')`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "6" {
+		t.Fatalf("got %s", got)
+	}
+
+	err = db.QueryRowContext(ctx, `SELECT ipfamily('[::1]:80')`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "6" {
+		t.Fatalf("got %s", got)
+	}
+
+	err = db.QueryRowContext(ctx, `SELECT ipfamily('192.168.1.5/24')`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "4" {
+		t.Fatalf("got %s", got)
+	}
+
+	err = db.QueryRowContext(ctx, `SELECT iphost('192.168.1.5/24')`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "192.168.1.5" {
+		t.Fatalf("got %s", got)
+	}
+
+	err = db.QueryRowContext(ctx, `SELECT ipmasklen('192.168.1.5/24')`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "24" {
+		t.Fatalf("got %s", got)
+	}
+
+	err = db.QueryRowContext(ctx, `SELECT ipnetwork('192.168.1.5/24')`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "192.168.1.0/24" {
+		t.Fatalf("got %s", got)
+	}
+
+	err = db.QueryRowContext(ctx, `SELECT ipcontains('192.168.1.0/24', '192.168.1.5')`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "1" {
+		t.Fatalf("got %s", got)
+	}
+
+	err = db.QueryRowContext(ctx, `SELECT ipoverlaps('192.168.1.0/24', '192.168.1.5/32')`).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "1" {
+		t.Fatalf("got %s", got)
+	}
+}

ext/lines/lines.go

@@ -18,8 +18,8 @@ import (
 	"io"
 	"io/fs"
 
-	"github.com/ncruces/go-sqlite3"
-	"github.com/ncruces/go-sqlite3/util/osutil"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/util/osutil"
 )
 
 // Register registers the lines and lines_read table-valued functions.
@@ -38,14 +38,18 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
 	return errors.Join(
 		sqlite3.CreateModule(db, "lines", nil,
 			func(db *sqlite3.Conn, _, _, _ string, _ ...string) (lines, error) {
-				err := db.DeclareVTab(`CREATE TABLE x(line TEXT, data HIDDEN)`)
-				db.VTabConfig(sqlite3.VTAB_INNOCUOUS)
+				err := db.DeclareVTab(`CREATE TABLE x(line TEXT, data HIDDEN, delim HIDDEN)`)
+				if err == nil {
+					err = db.VTabConfig(sqlite3.VTAB_INNOCUOUS)
+				}
 				return lines{}, err
 			}),
 		sqlite3.CreateModule(db, "lines_read", nil,
 			func(db *sqlite3.Conn, _, _, _ string, _ ...string) (lines, error) {
-				err := db.DeclareVTab(`CREATE TABLE x(line TEXT, data HIDDEN)`)
-				db.VTabConfig(sqlite3.VTAB_DIRECTONLY)
+				err := db.DeclareVTab(`CREATE TABLE x(line TEXT, data HIDDEN, delim HIDDEN)`)
+				if err == nil {
+					err = db.VTabConfig(sqlite3.VTAB_DIRECTONLY)
+				}
 				return lines{fsys}, err
 			}))
 }
@@ -54,19 +58,29 @@ type lines struct {
 	fsys fs.FS
 }
 
-func (l lines) BestIndex(idx *sqlite3.IndexInfo) error {
+func (l lines) BestIndex(idx *sqlite3.IndexInfo) (err error) {
+	err = sqlite3.CONSTRAINT
 	for i, cst := range idx.Constraint {
-		if cst.Column == 1 && cst.Op == sqlite3.INDEX_CONSTRAINT_EQ && cst.Usable {
+		if !cst.Usable || cst.Op != sqlite3.INDEX_CONSTRAINT_EQ {
+			continue
+		}
+		switch cst.Column {
+		case 1:
 			idx.ConstraintUsage[i] = sqlite3.IndexConstraintUsage{
 				Omit:      true,
 				ArgvIndex: 1,
 			}
 			idx.EstimatedCost = 1e6
 			idx.EstimatedRows = 100
-			return nil
+			err = nil
+		case 2:
+			idx.ConstraintUsage[i] = sqlite3.IndexConstraintUsage{
+				Omit:      true,
+				ArgvIndex: 2,
+			}
 		}
 	}
-	return sqlite3.CONSTRAINT
+	return err
 }
 
 func (l lines) Open() (sqlite3.VTabCursor, error) {
@@ -81,6 +95,7 @@ type cursor struct {
 	line  []byte
 	rowID int64
 	eof   bool
+	delim byte
 }
 
 func (c *cursor) EOF() bool {
@@ -136,6 +151,15 @@ func (c *reader) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
 		return fmt.Errorf("lines: unsupported argument:%.0w %v", sqlite3.MISMATCH, typ)
 	}
 
+	c.delim = '\n'
+	if len(arg) > 1 {
+		b := arg[1].RawText()
+		if len(b) != 1 {
+			return fmt.Errorf("lines: delimiter must be a single byte%.0w", sqlite3.MISMATCH)
+		}
+		c.delim = b[0]
+	}
+
 	c.reader = bufio.NewReader(r)
 	c.closer, _ = r.(io.Closer)
 	c.rowID = 0
@@ -146,7 +170,12 @@ func (c *reader) Next() (err error) {
 	c.line = c.line[:0]
 	for more := true; more; {
 		var line []byte
-		line, more, err = c.reader.ReadLine()
+		if c.delim == '\n' {
+			line, more, err = c.reader.ReadLine()
+		} else {
+			line, err = c.reader.ReadSlice(c.delim)
+			more = err == bufio.ErrBufferFull
+		}
 		c.line = append(c.line, line...)
 	}
 	if err == io.EOF {
@@ -173,18 +202,27 @@ func (c *buffer) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
 		return fmt.Errorf("lines: unsupported argument:%.0w %v", sqlite3.MISMATCH, typ)
 	}
 
+	c.delim = '\n'
+	if len(arg) > 1 {
+		b := arg[1].RawText()
+		if len(b) != 1 {
+			return fmt.Errorf("lines: delimiter must be a single byte%.0w", sqlite3.MISMATCH)
+		}
+		c.delim = b[0]
+	}
+
 	c.rowID = 0
 	return c.Next()
 }
 
 func (c *buffer) Next() error {
-	i := bytes.IndexByte(c.data, '\n')
+	i := bytes.IndexByte(c.data, c.delim)
 	j := i + 1
 	switch {
 	case i < 0:
 		i = len(c.data)
 		j = i
-	case i > 0 && c.data[i-1] == '\r':
+	case i > 0 && c.delim == '\n' && c.data[i-1] == '\r':
 		i--
 	}
 	c.eof = len(c.data) == 0

ext/lines/lines_test.go

@@ -10,12 +10,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/ncruces/go-sqlite3"
-	"github.com/ncruces/go-sqlite3/driver"
-	_ "github.com/ncruces/go-sqlite3/embed"
-	"github.com/ncruces/go-sqlite3/ext/lines"
-	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
-	"github.com/ncruces/go-sqlite3/vfs/memdb"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/driver"
+	"github.com/hanzoai/sqlite3/ext/lines"
+	"github.com/hanzoai/sqlite3/internal/testcfg"
+	"github.com/hanzoai/sqlite3/vfs/memdb"
 )
 
 func Example() {
@@ -67,9 +66,10 @@ func Example() {
 
 func Test_lines(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, lines.Register)
+	ctx := testcfg.Context(t)
+	db, err := driver.Open(dsn, lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -77,7 +77,7 @@ func Test_lines(t *testing.T) {
 
 	const data = "line 1\nline 2\r\nline 3\n"
 
-	rows, err := db.Query(`SELECT rowid, line FROM lines(?)`, data)
+	rows, err := db.QueryContext(ctx, `SELECT rowid, line FROM lines(?)`, data)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -98,22 +98,23 @@ func Test_lines(t *testing.T) {
 
 func Test_lines_error(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, lines.Register)
+	ctx := testcfg.Context(t)
+	db, err := driver.Open(dsn, lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer db.Close()
 
-	_, err = db.Exec(`SELECT rowid, line FROM lines(?)`, nil)
+	_, err = db.ExecContext(ctx, `SELECT rowid, line FROM lines(?)`, nil)
 	if err == nil {
 		t.Fatal("want error")
 	} else {
 		t.Log(err)
 	}
 
-	_, err = db.Exec(`SELECT rowid, line FROM lines_read(?)`, "xpto")
+	_, err = db.ExecContext(ctx, `SELECT rowid, line FROM lines_read(?)`, "xpto")
 	if err == nil {
 		t.Fatal("want error")
 	} else {
@@ -123,9 +124,10 @@ func Test_lines_error(t *testing.T) {
 
 func Test_lines_read(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, lines.Register)
+	ctx := testcfg.Context(t)
+	db, err := driver.Open(dsn, lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -133,7 +135,7 @@ func Test_lines_read(t *testing.T) {
 
 	const data = "line 1\nline 2\r\nline 3\n"
 
-	rows, err := db.Query(`SELECT rowid, line FROM lines_read(?)`,
+	rows, err := db.QueryContext(ctx, `SELECT rowid, line FROM lines_read(?)`,
 		sqlite3.Pointer(strings.NewReader(data)))
 	if err != nil {
 		t.Fatal(err)
@@ -155,15 +157,16 @@ func Test_lines_read(t *testing.T) {
 
 func Test_lines_test(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, lines.Register)
+	ctx := testcfg.Context(t)
+	db, err := driver.Open(dsn, lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer db.Close()
 
-	rows, err := db.Query(`SELECT rowid, line FROM lines_read(?)`, "lines_test.go")
+	rows, err := db.QueryContext(ctx, `SELECT rowid, line FROM lines_read(?, '}')`, "lines_test.go")
 	if errors.Is(err, os.ErrNotExist) {
 		t.Skip(err)
 	}

ext/pivot/op_test.go

@@ -3,7 +3,7 @@ package pivot
 import (
 	"testing"
 
-	"github.com/ncruces/go-sqlite3"
+	"github.com/hanzoai/sqlite3"
 )
 
 func Test_operator(t *testing.T) {

ext/pivot/pivot.go

@@ -8,8 +8,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/ncruces/go-sqlite3"
-	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/internal/errutil"
 )
 
 // Register registers the pivot virtual table.
@@ -25,15 +25,15 @@ type table struct {
 	cols []*sqlite3.Value
 }
 
-func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (_ *table, err error) {
+func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (ret *table, err error) {
 	if len(arg) != 3 {
 		return nil, fmt.Errorf("pivot: wrong number of arguments")
 	}
 
-	table := &table{db: db}
+	t := &table{db: db}
 	defer func() {
-		if err != nil {
-			table.Close()
+		if ret == nil {
+			t.Close()
 		}
 	}()
 
@@ -42,52 +42,66 @@ func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (_ *table, err err
 	create.WriteString("CREATE TABLE x(")
 
 	// Row key query.
-	table.scan = "SELECT * FROM\n" + arg[0]
-	stmt, _, err := db.Prepare(table.scan)
+	t.scan = "SELECT * FROM\n" + arg[0]
+	stmt, tail, err := db.PrepareFlags(t.scan, sqlite3.PREPARE_FROM_DDL)
 	if err != nil {
 		return nil, err
 	}
 	defer stmt.Close()
+	if tail != "" {
+		return nil, errutil.TailErr
+	}
 
-	table.keys = make([]string, stmt.ColumnCount())
-	for i := range table.keys {
+	t.keys = make([]string, stmt.ColumnCount())
+	for i := range t.keys {
 		name := sqlite3.QuoteIdentifier(stmt.ColumnName(i))
-		table.keys[i] = name
+		t.keys[i] = name
 		create.WriteString(sep)
 		create.WriteString(name)
+		create.WriteString(" ")
+		create.WriteString(stmt.ColumnDeclType(i))
 		sep = ","
 	}
 	stmt.Close()
 
 	// Column definition query.
-	stmt, _, err = db.Prepare("SELECT * FROM\n" + arg[1])
+	stmt, tail, err = db.PrepareFlags("SELECT * FROM\n"+arg[1], sqlite3.PREPARE_FROM_DDL)
 	if err != nil {
 		return nil, err
 	}
+	if tail != "" {
+		return nil, errutil.TailErr
+	}
 
 	if stmt.ColumnCount() != 2 {
-		return nil, util.ErrorString("pivot: column definition query expects 2 result columns")
+		return nil, errutil.ErrorString("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(",")
+		t.cols = append(t.cols, stmt.ColumnValue(0).Dup())
+		create.WriteString(sep)
 		create.WriteString(name)
+		create.WriteString(" ")
+		create.WriteString(stmt.ColumnDeclType(1))
+		sep = ","
 	}
 	stmt.Close()
 
 	// Pivot cell query.
-	table.cell = "SELECT * FROM\n" + arg[2]
-	stmt, _, err = db.Prepare(table.cell)
+	t.cell = "SELECT * FROM\n" + arg[2]
+	stmt, tail, err = db.PrepareFlags(t.cell, sqlite3.PREPARE_FROM_DDL)
 	if err != nil {
 		return nil, err
 	}
+	if tail != "" {
+		return nil, errutil.TailErr
+	}
 
 	if stmt.ColumnCount() != 1 {
-		return nil, util.ErrorString("pivot: cell query expects 1 result columns")
+		return nil, errutil.ErrorString("pivot: cell query expects 1 result columns")
 	}
-	if stmt.BindCount() != len(table.keys)+1 {
-		return nil, fmt.Errorf("pivot: cell query expects %d bound parameters", len(table.keys)+1)
+	if stmt.BindCount() != len(t.keys)+1 {
+		return nil, fmt.Errorf("pivot: cell query expects %d bound parameters", len(t.keys)+1)
 	}
 
 	create.WriteByte(')')
@@ -95,14 +109,15 @@ func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (_ *table, err err
 	if err != nil {
 		return nil, err
 	}
-	return table, nil
+	return t, nil
 }
 
 func (t *table) Close() error {
-	for i := range t.cols {
-		t.cols[i].Close()
+	var errs []error
+	for _, c := range t.cols {
+		errs = append(errs, c.Close())
 	}
-	return nil
+	return errors.Join(errs...)
 }
 
 func (t *table) BestIndex(idx *sqlite3.IndexInfo) error {
@@ -181,7 +196,9 @@ func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
 		return err
 	}
 
-	c.scan, _, err = c.table.db.Prepare(idxStr)
+	const prepflags = sqlite3.PREPARE_DONT_LOG | sqlite3.PREPARE_FROM_DDL
+
+	c.scan, _, err = c.table.db.PrepareFlags(idxStr, prepflags)
 	if err != nil {
 		return err
 	}
@@ -193,7 +210,7 @@ func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
 	}
 
 	if c.cell == nil {
-		c.cell, _, err = c.table.db.Prepare(c.table.cell)
+		c.cell, _, err = c.table.db.PrepareFlags(c.table.cell, prepflags)
 		if err != nil {
 			return err
 		}
@@ -206,7 +223,7 @@ func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
 func (c *cursor) Next() error {
 	if c.scan.Step() {
 		count := c.scan.ColumnCount()
-		for i := 0; i < count; i++ {
+		for i := range count {
 			err := c.cell.BindValue(i+1, c.scan.ColumnValue(i))
 			if err != nil {
 				return err

ext/pivot/pivot_test.go

@@ -3,13 +3,13 @@ package pivot_test
 import (
 	"fmt"
 	"log"
+	"os"
 	"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"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/ext/pivot"
+	"github.com/hanzoai/sqlite3/internal/testcfg"
 )
 
 // https://antonz.org/sqlite-pivot-table/
@@ -85,13 +85,13 @@ func Example() {
 
 func TestMain(m *testing.M) {
 	sqlite3.AutoExtension(pivot.Register)
-	m.Run()
+	os.Exit(m.Run())
 }
 
 func TestRegister(t *testing.T) {
 	t.Parallel()
 
-	db, err := sqlite3.Open(":memory:")
+	db, err := sqlite3.OpenContext(testcfg.Context(t), ":memory:")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -140,10 +140,10 @@ func TestRegister(t *testing.T) {
 	}
 	defer stmt.Close()
 
-	if stmt.Step() {
-		if got := stmt.ColumnInt(0); got != 3 {
-			t.Errorf("got %d, want 3", got)
-		}
+	if !stmt.Step() {
+		t.Fatal(stmt.Err())
+	} else if got := stmt.ColumnInt(0); got != 3 {
+		t.Errorf("got %d, want 3", got)
 	}
 
 	err = db.Exec(`ALTER TABLE v_x RENAME TO v_y`)
@@ -155,7 +155,7 @@ func TestRegister(t *testing.T) {
 func TestRegister_errors(t *testing.T) {
 	t.Parallel()
 
-	db, err := sqlite3.Open(":memory:")
+	db, err := sqlite3.OpenContext(testcfg.Context(t), ":memory:")
 	if err != nil {
 		t.Fatal(err)
 	}

ext/regexp/regexp.go

@@ -1,9 +1,11 @@
 // Package regexp provides additional regular expression functions.
 //
 // It provides the following Unicode aware functions:
-//   - regexp_like(),
-//   - regexp_substr(),
-//   - regexp_replace(),
+//   - regexp_like(text, pattern),
+//   - regexp_count(text, pattern [, start]),
+//   - regexp_instr(text, pattern [, start [, N [, endoption [, subexpr ]]]]),
+//   - regexp_substr(text, pattern [, start [, N [, subexpr ]]]),
+//   - regexp_replace(text, pattern, replacement [, start [, N ]]),
 //   - and a REGEXP operator.
 //
 // The implementation uses Go [regexp/syntax] for regular expressions.
@@ -14,65 +16,276 @@ package regexp
 import (
 	"errors"
 	"regexp"
+	"regexp/syntax"
+	"strings"
+	"unicode/utf8"
 
-	"github.com/ncruces/go-sqlite3"
+	"github.com/hanzoai/sqlite3"
 )
 
 // Register registers Unicode aware functions for a database connection.
 func Register(db *sqlite3.Conn) error {
-	flags := sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
+	const flags = sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
 	return errors.Join(
 		db.CreateFunction("regexp", 2, flags, regex),
 		db.CreateFunction("regexp_like", 2, flags, regexLike),
+		db.CreateFunction("regexp_count", 2, flags, regexCount),
+		db.CreateFunction("regexp_count", 3, flags, regexCount),
+		db.CreateFunction("regexp_instr", 2, flags, regexInstr),
+		db.CreateFunction("regexp_instr", 3, flags, regexInstr),
+		db.CreateFunction("regexp_instr", 4, flags, regexInstr),
+		db.CreateFunction("regexp_instr", 5, flags, regexInstr),
+		db.CreateFunction("regexp_instr", 6, flags, regexInstr),
 		db.CreateFunction("regexp_substr", 2, flags, regexSubstr),
-		db.CreateFunction("regexp_replace", 3, flags, regexReplace))
+		db.CreateFunction("regexp_substr", 3, flags, regexSubstr),
+		db.CreateFunction("regexp_substr", 4, flags, regexSubstr),
+		db.CreateFunction("regexp_substr", 5, flags, regexSubstr),
+		db.CreateFunction("regexp_replace", 3, flags, regexReplace),
+		db.CreateFunction("regexp_replace", 4, flags, regexReplace),
+		db.CreateFunction("regexp_replace", 5, flags, regexReplace))
 }
 
-func load(ctx sqlite3.Context, i int, expr string) (*regexp.Regexp, error) {
+// GlobPrefix returns a GLOB for a regular expression
+// appropriate to take advantage of the [LIKE optimization]
+// in a query such as:
+//
+//	SELECT column WHERE column GLOB :glob_prefix AND column REGEXP :regexp
+//
+// [LIKE optimization]: https://sqlite.org/optoverview.html#the_like_optimization
+func GlobPrefix(expr string) string {
+	re, err := syntax.Parse(expr, syntax.Perl)
+	if err != nil {
+		return "" // no match possible
+	}
+	prog, err := syntax.Compile(re.Simplify())
+	if err != nil {
+		return "" // notest
+	}
+
+	i := &prog.Inst[prog.Start]
+
+	var empty syntax.EmptyOp
+loop1:
+	for {
+		switch i.Op {
+		case syntax.InstFail:
+			return "" // notest
+		case syntax.InstCapture, syntax.InstNop:
+			// skip
+		case syntax.InstEmptyWidth:
+			empty |= syntax.EmptyOp(i.Arg)
+		default:
+			break loop1
+		}
+		i = &prog.Inst[i.Out]
+	}
+	if empty&syntax.EmptyBeginText == 0 {
+		return "*" // not anchored
+	}
+
+	var glob strings.Builder
+loop2:
+	for {
+		switch i.Op {
+		case syntax.InstFail:
+			return "" // notest
+		case syntax.InstCapture, syntax.InstEmptyWidth, syntax.InstNop:
+			// skip
+		case syntax.InstRune, syntax.InstRune1:
+			if len(i.Rune) != 1 || syntax.Flags(i.Arg)&syntax.FoldCase != 0 {
+				break loop2
+			}
+			switch r := i.Rune[0]; r {
+			case '*', '?', '[', utf8.RuneError:
+				break loop2
+			default:
+				glob.WriteRune(r)
+			}
+		default:
+			break loop2
+		}
+		i = &prog.Inst[i.Out]
+	}
+
+	glob.WriteByte('*')
+	return glob.String()
+}
+
+func load(ctx sqlite3.Context, arg []sqlite3.Value, i int) (*regexp.Regexp, error) {
 	re, ok := ctx.GetAuxData(i).(*regexp.Regexp)
 	if !ok {
-		r, err := regexp.Compile(expr)
-		if err != nil {
-			return nil, err
+		re, ok = arg[i].Pointer().(*regexp.Regexp)
+		if !ok {
+			r, err := regexp.Compile(arg[i].Text())
+			if err != nil {
+				return nil, err
+			}
+			re = r
 		}
-		re = r
-		ctx.SetAuxData(0, r)
+		ctx.SetAuxData(i, re)
 	}
 	return re, nil
 }
 
 func regex(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	re, err := load(ctx, 0, arg[0].Text())
+	re, err := load(ctx, arg, 0)
 	if err != nil {
-		ctx.ResultError(err) // notest
-	} else {
-		ctx.ResultBool(re.Match(arg[1].RawText()))
+		ctx.ResultError(err)
+		return // notest
 	}
+	text := arg[1].RawText()
+	ctx.ResultBool(re.Match(text))
 }
 
 func regexLike(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	re, err := load(ctx, 1, arg[1].Text())
+	re, err := load(ctx, arg, 1)
 	if err != nil {
-		ctx.ResultError(err) // notest
-	} else {
-		ctx.ResultBool(re.Match(arg[0].RawText()))
+		ctx.ResultError(err)
+		return // notest
 	}
+	text := arg[0].RawText()
+	ctx.ResultBool(re.Match(text))
+}
+
+func regexCount(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	re, err := load(ctx, arg, 1)
+	if err != nil {
+		ctx.ResultError(err)
+		return // notest
+	}
+
+	text := arg[0].RawText()
+	if len(arg) > 2 {
+		pos := arg[2].Int()
+		text = text[skip(text, pos):]
+	}
+	ctx.ResultInt(len(re.FindAll(text, -1)))
 }
 
 func regexSubstr(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	re, err := load(ctx, 1, arg[1].Text())
+	re, err := load(ctx, arg, 1)
 	if err != nil {
-		ctx.ResultError(err) // notest
-	} else {
-		ctx.ResultRawText(re.Find(arg[0].RawText()))
+		ctx.ResultError(err)
+		return // notest
+	}
+
+	text := arg[0].RawText()
+	var pos, n, subexpr int
+	if len(arg) > 2 {
+		pos = arg[2].Int()
+	}
+	if len(arg) > 3 {
+		n = arg[3].Int()
+	}
+	if len(arg) > 4 {
+		subexpr = arg[4].Int()
+	}
+
+	loc := regexFind(re, text, pos, n, subexpr)
+	if loc != nil {
+		ctx.ResultRawText(text[loc[0]:loc[1]])
+	}
+}
+
+func regexInstr(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	re, err := load(ctx, arg, 1)
+	if err != nil {
+		ctx.ResultError(err)
+		return // notest
+	}
+
+	text := arg[0].RawText()
+	var pos, n, end, subexpr int
+	if len(arg) > 2 {
+		pos = arg[2].Int()
+	}
+	if len(arg) > 3 {
+		n = arg[3].Int()
+	}
+	if len(arg) > 4 && arg[4].Bool() {
+		end = 1
+	}
+	if len(arg) > 5 {
+		subexpr = arg[5].Int()
+	}
+
+	loc := regexFind(re, text, pos, n, subexpr)
+	if loc != nil {
+		ctx.ResultInt(loc[end] + 1)
 	}
 }
 
 func regexReplace(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	re, err := load(ctx, 1, arg[1].Text())
+	re, err := load(ctx, arg, 1)
 	if err != nil {
-		ctx.ResultError(err) // notest
-	} else {
-		ctx.ResultRawText(re.ReplaceAll(arg[0].RawText(), arg[2].RawText()))
+		ctx.ResultError(err)
+		return // notest
 	}
+
+	repl := arg[2].RawText()
+	text := arg[0].RawText()
+	var pos, n int
+	if len(arg) > 3 {
+		pos = arg[3].Int()
+	}
+	if len(arg) > 4 {
+		n = arg[4].Int()
+	}
+
+	res := text
+	pos = skip(text, pos)
+	if n > 0 {
+		all := re.FindAllSubmatchIndex(text[pos:], n)
+		if n <= len(all) {
+			loc := all[n-1]
+			res = text[:pos+loc[0]]
+			res = re.Expand(res, repl, text[pos:], loc)
+			res = append(res, text[pos+loc[1]:]...)
+		}
+	} else {
+		res = append(text[:pos], re.ReplaceAll(text[pos:], repl)...)
+	}
+	ctx.ResultRawText(res)
+}
+
+func regexFind(re *regexp.Regexp, text []byte, pos, n, subexpr int) (loc []int) {
+	pos = skip(text, pos)
+	text = text[pos:]
+
+	if n <= 1 {
+		if subexpr == 0 {
+			loc = re.FindIndex(text)
+		} else {
+			loc = re.FindSubmatchIndex(text)
+		}
+	} else {
+		if subexpr == 0 {
+			all := re.FindAllIndex(text, n)
+			if n <= len(all) {
+				loc = all[n-1]
+			}
+		} else {
+			all := re.FindAllSubmatchIndex(text, n)
+			if n <= len(all) {
+				loc = all[n-1]
+			}
+		}
+	}
+
+	if 2+2*subexpr <= len(loc) {
+		loc = loc[2*subexpr : 2+2*subexpr]
+		loc[0] += pos
+		loc[1] += pos
+		return loc
+	}
+	return nil
+}
+
+func skip(text []byte, start int) int {
+	for pos := range string(text) {
+		if start--; start <= 0 {
+			return pos
+		}
+	}
+	return len(text)
 }

ext/regexp/regexp_test.go

@@ -1,19 +1,23 @@
 package regexp
 
 import (
+	"database/sql"
+	"regexp"
+	"strings"
 	"testing"
 
-	"github.com/ncruces/go-sqlite3/driver"
-	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
-	"github.com/ncruces/go-sqlite3/vfs/memdb"
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/driver"
+	"github.com/hanzoai/sqlite3/internal/testcfg"
+	"github.com/hanzoai/sqlite3/vfs/memdb"
 )
 
 func TestRegister(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, Register)
+	ctx := testcfg.Context(t)
+	db, err := driver.Open(dsn, Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -29,27 +33,57 @@ func TestRegister(t *testing.T) {
 		{`regexp_like('Hello', 'elo')`, "0"},
 		{`regexp_like('Hello', 'ell')`, "1"},
 		{`regexp_like('Hello', 'el.')`, "1"},
+		{`regexp_count('Hello', 'l')`, "2"},
+		{`regexp_instr('Hello', 'el.')`, "2"},
+		{`regexp_instr('Hello', '.', 6)`, ""},
 		{`regexp_substr('Hello', 'el.')`, "ell"},
 		{`regexp_replace('Hello', 'llo', 'll')`, "Hell"},
+		// https://postgresql.org/docs/current/functions-matching.html
+		{`regexp_count('ABCABCAXYaxy', 'A.')`, "3"},
+		{`regexp_count('ABCABCAXYaxy', '(?i)A.', 1)`, "4"},
+		{`regexp_instr('number of your street, town zip, FR', '[^,]+', 1, 2)`, "23"},
+		{`regexp_instr('ABCDEFGHI', '(?i)(c..)(...)', 1, 1, 0, 2)`, "6"},
+		{`regexp_substr('number of your street, town zip, FR', '[^,]+', 1, 2)`, " town zip"},
+		{`regexp_substr('ABCDEFGHI', '(?i)(c..)(...)', 1, 1, 2)`, "FGH"},
+		{`regexp_replace('foobarbaz', 'b..', 'X', 1, 1)`, "fooXbaz"},
+		{`regexp_replace('foobarbaz', 'b..', 'X')`, "fooXX"},
+		{`regexp_replace('foobarbaz', 'b(..)', 'X${1}Y')`, "fooXarYXazY"},
+		{`regexp_replace('A PostgreSQL function', '(?i)a|e|i|o|u', 'X', 1, 0)`, "X PXstgrXSQL fXnctXXn"},
+		{`regexp_replace('A PostgreSQL function', '(?i)a|e|i|o|u', 'X', 1, 3)`, "A PostgrXSQL function"},
+		// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/REGEXP_COUNT.html
+		{`regexp_count('123123123123123', '(12)3', 1)`, "5"},
+		{`regexp_count('123123123123', '123', 3)`, "3"},
+		{`regexp_instr('500 Oracle Parkway, Redwood Shores, CA', '[^ ]+', 1, 6)`, "37"},
+		{`regexp_instr('500 Oracle Parkway, Redwood Shores, CA', '(?i)[s|r|p][[:alpha:]]{6}', 3, 2, 1)`, "28"},
+		{`regexp_instr('1234567890', '(123)(4(56)(78))', 1, 1, 0, 1)`, "1"},
+		{`regexp_instr('1234567890', '(123)(4(56)(78))', 1, 1, 0, 2)`, "4"},
+		{`regexp_instr('1234567890', '(123)(4(56)(78))', 1, 1, 0, 4)`, "7"},
+		{`regexp_substr('500 Oracle Parkway, Redwood Shores, CA', ',[^,]+,')`, ", Redwood Shores,"},
+		{`regexp_substr('http://www.example.com/products', 'http://([[:alnum:]]+\.?){3,4}/?')`, "http://www.example.com/"},
+		{`regexp_substr('1234567890', '(123)(4(56)(78))', 1, 1, 1)`, "123"},
+		{`regexp_substr('1234567890', '(123)(4(56)(78))', 1, 1, 4)`, "78"},
+		{`regexp_substr('123123123123', '1(.)3', 3, 2, 1)`, "2"},
+		{`regexp_replace('500   Oracle     Parkway,    Redwood  Shores, CA', '( ){2,}', ' ')`, "500 Oracle Parkway, Redwood Shores, CA"},
 	}
 
 	for _, tt := range tests {
-		var got string
-		err := db.QueryRow(`SELECT ` + tt.test).Scan(&got)
+		var got sql.NullString
+		err := db.QueryRowContext(ctx, `SELECT `+tt.test).Scan(&got)
 		if err != nil {
 			t.Fatal(err)
 		}
-		if got != tt.want {
-			t.Errorf("got %q, want %q", got, tt.want)
+		if got.String != tt.want {
+			t.Errorf("got %q, want %q", got.String, tt.want)
 		}
 	}
 }
 
 func TestRegister_errors(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, Register)
+	ctx := testcfg.Context(t)
+	db, err := driver.Open(dsn, Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -58,14 +92,96 @@ func TestRegister_errors(t *testing.T) {
 	tests := []string{
 		`'' REGEXP ?`,
 		`regexp_like('', ?)`,
+		`regexp_count('', ?)`,
+		`regexp_instr('', ?)`,
 		`regexp_substr('', ?)`,
 		`regexp_replace('', ?, '')`,
 	}
 
 	for _, tt := range tests {
-		err := db.QueryRow(`SELECT `+tt, `\`).Scan(nil)
+		err := db.QueryRowContext(ctx, `SELECT `+tt, `\`).Scan(nil)
 		if err == nil {
 			t.Fatal("want error")
 		}
 	}
 }
+
+func TestRegister_pointer(t *testing.T) {
+	t.Parallel()
+	dsn := memdb.TestDB(t)
+
+	ctx := testcfg.Context(t)
+	db, err := driver.Open(dsn, Register)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	var got int
+	err = db.QueryRowContext(ctx, `SELECT regexp_count('ABCABCAXYaxy', ?, 1)`,
+		sqlite3.Pointer(regexp.MustCompile(`(?i)A.`))).Scan(&got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != 4 {
+		t.Errorf("got %d, want %d", got, 4)
+	}
+}
+
+func TestGlobPrefix(t *testing.T) {
+	tests := []struct {
+		re   string
+		want string
+	}{
+		{`[`, ""},
+		{``, "*"},
+		{`^`, "*"},
+		{`a`, "*"},
+		{`ab`, "*"},
+		{`^a`, "a*"},
+		{`^a*`, "*"},
+		{`^a+`, "a*"},
+		{`^ab*`, "a*"},
+		{`^ab+`, "ab*"},
+		{`^a\?b`, "a*"},
+		{`^[a-z]`, "*"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.re, func(t *testing.T) {
+			if got := GlobPrefix(tt.re); got != tt.want {
+				t.Errorf("GlobPrefix(%v) = %v, want %v", tt.re, got, tt.want)
+			}
+		})
+	}
+}
+
+func FuzzGlobPrefix(f *testing.F) {
+	f.Add(``, ``)
+	f.Add(`[`, ``)
+	f.Add(`^`, ``)
+	f.Add(`a`, `a`)
+	f.Add(`ab`, `b`)
+	f.Add(`^a`, `a`)
+	f.Add(`^a*`, `ab`)
+	f.Add(`^a+`, `ab`)
+	f.Add(`^ab*`, `ab`)
+	f.Add(`^ab+`, `ab`)
+	f.Add(`^a\?b`, `ab`)
+	f.Add(`^[a-z]`, `ab`)
+
+	f.Fuzz(func(t *testing.T, lit, str string) {
+		re, err := regexp.Compile(lit)
+		if err != nil {
+			t.SkipNow()
+		}
+		if re.MatchString(str) {
+			prefix, ok := strings.CutSuffix(GlobPrefix(lit), "*")
+			if !ok {
+				t.Fatalf("missing * after %q for %q with %q", prefix, lit, str)
+			}
+			if !strings.HasPrefix(str, prefix) {
+				t.Fatalf("missing prefix %q for %q with %q", prefix, lit, str)
+			}
+		}
+	})
+}

ext/rtree/rtree.go

@@ -0,0 +1,15 @@
+// Package rtree provides the rtree and geopoly virtual tables.
+//
+// https://sqlite.org/rtree.html
+// https://sqlite.org/geopoly.html
+package rtree
+
+import (
+	"github.com/hanzoai/sqlite3"
+	"github.com/ncruces/go-sqlite3-wasm/v3/rtree"
+)
+
+// Register registers the rtree and geopoly virtual tables.
+func Register(db *sqlite3.Conn) error {
+	return sqlite3.ExtensionInit(db, rtree.New, rtree.DylinkInfo)
+}

ext/rtree/rtree_test.go

@@ -0,0 +1,63 @@
+package rtree_test
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/hanzoai/sqlite3/driver"
+	"github.com/hanzoai/sqlite3/ext/rtree"
+	_ "github.com/hanzoai/sqlite3/vfs/memdb"
+)
+
+func Example_rtree() {
+	db, err := driver.Open("file:/test.db?vfs=memdb", rtree.Register)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec(`
+		CREATE VIRTUAL TABLE locations USING rtree(id, minX, maxX, minY, maxY);
+		INSERT INTO locations VALUES (1, -10.0, -5.0, 30.0, 35.0);
+		INSERT INTO locations VALUES (2, 100.0, 105.0, 0.0, 5.0);
+	`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	var id int
+	err = db.QueryRow(`SELECT id FROM locations WHERE 
+		minX >= -12.0 AND maxX <= -4.0 AND 
+		minY >= 28.0 AND maxY <= 36.0`).Scan(&id)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Println(id)
+	// Output: 1
+}
+
+func Example_geopoly() {
+	db, err := driver.Open("file:/test.db?vfs=memdb", rtree.Register)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec(`
+		CREATE VIRTUAL TABLE areas USING geopoly(name);
+		INSERT INTO areas(name, _shape) VALUES ('Triangle Area', '[[0,0],[2,0],[1,2],[0,0]]');
+	`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	var name string
+	err = db.QueryRow("SELECT name FROM areas WHERE geopoly_contains_point(_shape, 1.0, 1.0)").Scan(&name)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Println(name)
+	// Output: Triangle Area
+}

ext/serdes/serdes.go

@@ -0,0 +1,72 @@
+// Package serdes provides functions to (de)serialize databases.
+package serdes
+
+import (
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/util/vfsutil"
+	"github.com/hanzoai/sqlite3/vfs"
+)
+
+const vfsName = "github.com/hanzoai/sqlite3/ext/serdes.sliceVFS"
+
+func init() {
+	vfs.Register(vfsName, sliceVFS{})
+}
+
+var fileToOpen = make(chan *[]byte, 1)
+
+// Serialize backs up a database into a byte slice.
+//
+// https://sqlite.org/c3ref/serialize.html
+func Serialize(db *sqlite3.Conn, schema string) ([]byte, error) {
+	var file []byte
+	fileToOpen <- &file
+	err := db.Backup(schema, "file:serdes.db?nolock=1&vfs="+vfsName)
+	return file, err
+}
+
+// Deserialize restores a database from a byte slice,
+// DESTROYING any contents previously stored in schema.
+//
+// To non-destructively open a database from a byte slice,
+// consider alternatives like the ["reader"] or ["memdb"] VFSes.
+//
+// This differs from the similarly named SQLite API
+// in that it DOES NOT disconnect from schema
+// to reopen as an in-memory database.
+//
+// https://sqlite.org/c3ref/deserialize.html
+//
+// ["memdb"]: https://pkg.go.dev/github.com/hanzoai/sqlite3/vfs/memdb
+// ["reader"]: https://pkg.go.dev/github.com/hanzoai/sqlite3/vfs/readervfs
+func Deserialize(db *sqlite3.Conn, schema string, data []byte) error {
+	fileToOpen <- &data
+	return db.Restore(schema, "file:serdes.db?immutable=1&vfs="+vfsName)
+}
+
+type sliceVFS struct{}
+
+func (sliceVFS) Open(name string, flags vfs.OpenFlag) (vfs.File, vfs.OpenFlag, error) {
+	if flags&vfs.OPEN_MAIN_DB == 0 || name != "serdes.db" {
+		return nil, flags, sqlite3.CANTOPEN
+	}
+	select {
+	case file := <-fileToOpen:
+		return (*vfsutil.SliceFile)(file), flags | vfs.OPEN_MEMORY, nil
+	default:
+		return nil, flags, sqlite3.MISUSE
+	}
+}
+
+func (sliceVFS) Delete(name string, dirSync bool) error {
+	// notest // no journals to delete
+	return sqlite3.IOERR_DELETE
+}
+
+func (sliceVFS) Access(name string, flag vfs.AccessFlag) (bool, error) {
+	return name == "serdes.db", nil
+}
+
+func (sliceVFS) FullPathname(name string) (string, error) {
+	return name, nil
+}

ext/serdes/serdes_test.go

@@ -0,0 +1,120 @@
+package serdes_test
+
+import (
+	_ "embed"
+	"errors"
+	"io"
+	"net/http"
+	"testing"
+
+	"github.com/hanzoai/sqlite3"
+	"github.com/hanzoai/sqlite3/ext/serdes"
+	"github.com/hanzoai/sqlite3/internal/testcfg"
+	"github.com/hanzoai/sqlite3/vfs"
+)
+
+//go:embed testdata/wal.db
+var walDB []byte
+
+func Test_wal(t *testing.T) {
+	if !vfs.SupportsFileLocking {
+		t.Skip("skipping without locks")
+	}
+
+	db, err := sqlite3.OpenContext(testcfg.Context(t), "testdata/wal.db")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	data, err := serdes.Serialize(db, "main")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	compareDBs(t, data, walDB)
+
+	err = serdes.Deserialize(db, "temp", walDB)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func Test_northwind(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping in short mode")
+	}
+
+	input, err := httpGet()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	db, err := sqlite3.OpenContext(testcfg.Context(t), ":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = serdes.Deserialize(db, "temp", input)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	output, err := serdes.Serialize(db, "temp")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	compareDBs(t, input, output)
+}
+
+func compareDBs(t *testing.T, a, b []byte) {
+	if len(a) != len(b) {
+		t.Fatal("lengths are different")
+	}
+	for i := range a {
+		// These may be different.
+		switch {
+		case 24 <= i && i < 28:
+			// File change counter.
+			continue
+		case 40 <= i && i < 44:
+			// Schema cookie.
+			continue
+		case 92 <= i && i < 100:
+			// SQLite version that wrote the file.
+			continue
+		}
+		if a[i] != b[i] {
+			t.Errorf("difference at %d: %d %d", i, a[i], b[i])
+		}
+	}
+}
+
+func httpGet() ([]byte, error) {
+	res, err := http.Get("https://github.com/jpwhite3/northwind-SQLite3/raw/refs/heads/main/dist/northwind.db")
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+	return io.ReadAll(res.Body)
+}
+
+func TestOpen_errors(t *testing.T) {
+	_, err := sqlite3.OpenContext(testcfg.Context(t), "file:test.db?vfs=github.com/hanzoai/sqlite3/ext/serdes.sliceVFS")
+	if err == nil {
+		t.Error("want error")
+	}
+	if !errors.Is(err, sqlite3.CANTOPEN) {
+		t.Errorf("got %v, want sqlite3.CANTOPEN", err)
+	}
+
+	_, err = sqlite3.OpenContext(testcfg.Context(t), "file:serdes.db?vfs=github.com/hanzoai/sqlite3/ext/serdes.sliceVFS")
+	if err == nil {
+		t.Error("want error")
+	}
+	if !errors.Is(err, sqlite3.MISUSE) {
+		t.Errorf("got %v, want sqlite3.MISUSE", err)
+	}
+}

ext/spellfix1/spellfix.go

@@ -0,0 +1,14 @@
+// Package spellfix1 provides the spellfix1 virtual table.
+//
+// https://sqlite.org/spellfix1.html
+package spellfix1
+
+import (
+	"github.com/hanzoai/sqlite3"
+	"github.com/ncruces/go-sqlite3-wasm/v3/spellfix"
+)
+
+// Register registers the spellfix1 virtual table.
+func Register(db *sqlite3.Conn) error {
+	return sqlite3.ExtensionInit(db, spellfix.New, spellfix.DylinkInfo)
+}