Dependencies.

Fixes https://github.com/go-gorm/sqlite/issues/192.

.github/actions/vmactions/template.yml

@@ -0,0 +1,16 @@
+name: VM Actions matrix
+description: VM Actions matrix template
+
+inputs:
+  run:
+    description: The CI command to run
+    required: true
+
+runs:
+  using: composite
+  steps:
+    - uses: ${VMACTIONS}
+      with:
+        usesh: true
+        copyback: false
+        run: ${{inputs.run}}

.github/dependabot.yml

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

.github/workflows/build-test.sh

@@ -0,0 +1,15 @@
+#!/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 ${BUILDFLAGS:-})
+  [ -f "${dir}/${name}" ] && echo "(cd ${dir}; ./${name} ${TESTFLAGS:-})" >> test.sh
+done
+
+if [[ -v VMACTIONS ]]; then
+  envsubst < .github/actions/vmactions/template.yml > .github/actions/vmactions/action.yml
+fi

.github/workflows/codeql.yml

@@ -1,76 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ "main" ]
-  schedule:
-    - cron: '15 18 * * 6'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'go' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
-        # Use only 'java' to analyze code written in Java, Kotlin or both
-        # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both
-        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v3
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-
-        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-        # queries: security-extended,security-and-quality
-
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, Go, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
-
-    #   If the Autobuild fails above, remove it and uncomment the following three lines.
-    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
-
-    # - run: |
-    #     echo "Run, Build Application using script"
-    #     ./location_of_script_within_repo/buildscript.sh
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
-      with:
-        category: "/language:${{matrix.language}}"

.github/workflows/go.yml

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

.github/workflows/repro.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ "$OSTYPE" == "linux"* ]]; then
+  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-25/wasi-sdk-25.0-x86_64-linux.tar.gz"
+  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_121/binaryen-version_121-x86_64-linux.tar.gz"
+elif [[ "$OSTYPE" == "darwin"* ]]; then
+  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-25/wasi-sdk-25.0-arm64-macos.tar.gz"
+  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_121/binaryen-version_121-arm64-macos.tar.gz"
+elif [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" ]]; then
+  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-25/wasi-sdk-25.0-x86_64-windows.tar.gz"
+  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_121/binaryen-version_121-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/sql3util/wasm/download.sh
+util/sql3util/wasm/build.sh
+
+# Check diffs
+git diff --exit-code

.github/workflows/repro.yml

@@ -0,0 +1,32 @@
+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
+
+    - name: Build
+      shell: bash
+      run: .github/workflows/repro.sh
+
+    - uses: actions/attest-build-provenance@v2
+      if: matrix.os == 'ubuntu-latest'
+      with:
+        subject-path: |
+          embed/sqlite3.wasm
+          embed/bcw2/bcw2.wasm
+          util/sql3util/wasm/sql3parse_table.wasm

.github/workflows/test.yml

@@ -0,0 +1,218 @@
+name: Test
+
+on:
+  push:
+    branches: [ 'main' ]
+    paths:
+      - '**.go'
+      - '**.mod'
+      - '**.wasm'
+  pull_request:
+    branches: [ 'main' ]
+    paths:
+      - '**.go'
+      - '**.mod'
+      - '**.wasm'
+  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: Format
+      run: gofmt -s -w . && git diff --exit-code
+      if: matrix.os != 'windows-latest'
+
+    - name: Tidy
+      run: go mod tidy && git diff --exit-code
+
+    - name: Download
+      run: go mod download
+
+    - name: Verify
+      run: go mod verify
+
+    - name: Vet
+      run: go vet ./...
+
+    - name: Build
+      run: go build -v ./...
+
+    - name: Test
+      run: go test -v ./... -bench . -benchtime=1x
+
+    - name: Test BSD locks
+      run: go test -v -tags sqlite3_flock ./...
+      if: matrix.os != 'windows-latest'
+
+    - name: Test dot locks
+      run: go test -v -tags sqlite3_dotlk ./...
+      if: matrix.os != 'windows-latest'
+
+    - name: Test GORM
+      shell: bash
+      run: gormlite/test.sh
+
+    - name: Test modules
+      shell: bash
+      run: go test -v ./embed/bcw2/...
+
+    - name: Collect coverage
+      run: go run github.com/dave/courtney@latest
+      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-bsd:
+    strategy:
+      matrix:
+        os:
+          - name: freebsd
+            version: '14.2'
+            flags: '-test.v'
+          - name: netbsd
+            version: '10.0'
+            flags: '-test.v'
+          - name: freebsd
+            arch: arm64
+            version: '14.2'
+            flags: '-test.v -test.short'
+          - name: netbsd
+            arch: arm64
+            version: '10.0'
+            flags: '-test.v -test.short'
+          - name: openbsd
+            version: '7.6'
+            flags: '-test.v -test.short'
+    runs-on: ubuntu-latest
+    needs: test
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Build
+      env:
+        GOOS: ${{ matrix.os.name }}
+        GOARCH: ${{ matrix.os.arch }}
+        TESTFLAGS: ${{ matrix.os.flags }}
+      run: .github/workflows/build-test.sh
+
+    - name: Test
+      uses: cross-platform-actions/action@v0.26.0
+      with:
+        operating_system: ${{ matrix.os.name }}
+        architecture: ${{ matrix.os.arch }}
+        version: ${{ matrix.os.version }}
+        shell: bash
+        run: . ./test.sh
+        sync_files: runner-to-vm
+
+  test-vm:
+    strategy:
+      matrix:
+        os:
+          - name: dragonfly
+            action: 'vmactions/dragonflybsd-vm@v1'
+            tflags: '-test.v'
+          - name: illumos
+            action: 'vmactions/omnios-vm@v1'
+            tflags: '-test.v'
+          - name: solaris
+            action: 'vmactions/solaris-vm@v1'
+            bflags: '-tags sqlite3_dotlk'
+            tflags: '-test.v'
+    runs-on: ubuntu-latest
+    needs: test
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Build
+      env:
+        GOOS: ${{ matrix.os.name }}
+        BUILDFLAGS: ${{ matrix.os.bflags }}
+        TESTFLAGS:  ${{ matrix.os.tflags }}
+        VMACTIONS:  ${{ matrix.os.action }}
+      run: .github/workflows/build-test.sh
+
+    - name: Test
+      uses: ./.github/actions/vmactions
+      with:
+        usesh: true
+        copyback: false
+        run: . ./test.sh
+
+  test-wasip1:
+    runs-on: ubuntu-latest
+    needs: test
+
+    steps:
+    - uses: bytecodealliance/actions/wasmtime/setup@v1
+    - uses: actions/checkout@v4
+    - uses: actions/setup-go@v5
+      with: { go-version: stable }
+
+    - name: Set path
+      run: echo "$(go env GOROOT)/misc/wasm" >> "$GITHUB_PATH"
+
+    - name: Test wasmtime
+      env:
+        GOOS: wasip1
+        GOARCH: wasm
+        GOWASIRUNTIME: wasmtime
+        GOWASIRUNTIMEARGS: '--env CI=true'
+      run: go test -v -short -tags sqlite3_dotlk -skip Example ./...
+
+  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: 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 ppc64le (interpreter)
+      run: GOARCH=ppc64le go test -v -short ./...
+
+    - name: Test s390x (big-endian)
+      run: GOARCH=s390x go test -v -short -tags sqlite3_dotlk ./...
+
+  test-macintel:
+    runs-on: macos-13
+    needs: test
+
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-go@v5
+      with: { go-version: stable }
+
+    - name: Test
+      run: go test -v ./...

README.md

@@ -1,82 +1,109 @@
-# Go bindings to SQLite using Wazero
+# Go bindings to SQLite using wazero
 
 [![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)
 [![Go Coverage](https://github.com/ncruces/go-sqlite3/wiki/coverage.svg)](https://github.com/ncruces/go-sqlite3/wiki/Test-coverage-report)
 
-Go module `github.com/ncruces/go-sqlite3` wraps a [WASM](https://webassembly.org/) build of [SQLite](https://sqlite.org/),
-and uses [wazero](https://wazero.io/) to provide `cgo`-free SQLite bindings.
+Go module `github.com/ncruces/go-sqlite3` is a `cgo`-free [SQLite](https://sqlite.org/) wrapper.\
+It provides a [`database/sql`](https://pkg.go.dev/database/sql) compatible driver,
+as well as direct access to most of the [C SQLite API](https://sqlite.org/cintro.html).
 
-- Package [`github.com/ncruces/go-sqlite3`](https://pkg.go.dev/github.com/ncruces/go-sqlite3)
-wraps the [C SQLite API](https://www.sqlite.org/cintro.html)
-([example usage](https://pkg.go.dev/github.com/ncruces/go-sqlite3#example-package)).
-- 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)).
-- 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.
-- Package [`github.com/ncruces/go-sqlite3/vfs`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs)
-wraps the [C SQLite VFS API](https://www.sqlite.org/vfs.html) and provides a pure Go implementation.
-- Package [`github.com/ncruces/go-sqlite3/gormlite`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/gormlite)
-provides a [GORM](https://gorm.io) driver.
+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_ direct dependencies.
+
+### Getting started
+
+Using the [`database/sql`](https://pkg.go.dev/database/sql) driver:
+```go
+
+import "database/sql"
+import _ "github.com/ncruces/go-sqlite3/driver"
+import _ "github.com/ncruces/go-sqlite3/embed"
+
+var version string
+db, _ := sql.Open("sqlite3", "file:demo.db")
+db.QueryRow(`SELECT sqlite_version()`).Scan(&version)
+```
+
+### Packages
+
+- [`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)).
+- [`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.
+- [`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.
+
+### Advanced features
+
+- [incremental BLOB I/O](https://sqlite.org/c3ref/blob_open.html)
+- [nested transactions](https://sqlite.org/lang_savepoint.html)
+- [custom functions](https://sqlite.org/c3ref/create_function.html)
+- [virtual tables](https://sqlite.org/vtab.html)
+- [custom VFSes](https://sqlite.org/vfs.html)
+- [online backup](https://sqlite.org/backup.html)
+- [JSON support](https://sqlite.org/json1.html)
+- [math functions](https://sqlite.org/lang_mathfunc.html)
+- [full-text search](https://sqlite.org/fts5.html)
+- [geospatial search](https://sqlite.org/geopoly.html)
+- [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)
+- [many extensions](ext/README.md)
+- [custom VFSes](vfs/README.md#custom-vfses)
+- [and more…](embed/README.md)
 
 ### Caveats
 
-This module replaces the SQLite [OS Interface](https://www.sqlite.org/vfs.html)
-(aka VFS) with a [pure Go](vfs/) implementation.
-This has benefits, but also comes with some drawbacks.
+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.
 
-#### Write-Ahead Logging
+Read more about the Go VFS design [here](vfs/README.md).
 
-Because WASM does not support shared memory,
-[WAL](https://www.sqlite.org/wal.html) support is [limited](https://www.sqlite.org/wal.html#noshm).
+### Testing
 
-To work around this limitation, SQLite is [patched](sqlite3/locking_mode.patch)
-to always use `EXCLUSIVE` locking mode for WAL databases.
+This project aims for [high test coverage](https://github.com/ncruces/go-sqlite3/wiki/Test-coverage-report).
+It also benefits greatly from [SQLite's](https://sqlite.org/testing.html) and
+[wazero's](https://tetrate.io/blog/introducing-wazero-from-tetrate/#:~:text=Rock%2Dsolid%20test%20approach) thorough testing.
 
-Because connection pooling is incompatible with `EXCLUSIVE` locking mode,
-to open WAL databases you should disable connection pooling by calling
-[`db.SetMaxOpenConns(1)`](https://pkg.go.dev/database/sql#DB.SetMaxOpenConns).
+Every commit is [tested](https://github.com/ncruces/go-sqlite3/wiki/Support-matrix) on
+Linux (amd64/arm64/386/riscv64/ppc64le/s390x), macOS (amd64/arm64),
+Windows (amd64), FreeBSD (amd64/arm64), OpenBSD (amd64), NetBSD (amd64/arm64),
+DragonFly BSD (amd64), illumos (amd64), and Solaris (amd64).
 
-#### POSIX Advisory Locks
+The Go VFS is tested by running SQLite's
+[mptest](https://github.com/sqlite/sqlite/blob/master/mptest/mptest.c).
 
-POSIX advisory locks, which SQLite uses, are
-[broken by design](https://www.sqlite.org/src/artifact/90c4fa?ln=1073-1161).
+### Performance
 
-On Linux, macOS and illumos, this module uses
-[OFD locks](https://www.gnu.org/software/libc/manual/html_node/Open-File-Description-Locks.html)
-to synchronize access to database files.
-OFD locks are fully compatible with process-associated POSIX advisory locks.
+Perfomance of the [`database/sql`](https://pkg.go.dev/database/sql) driver is
+[competitive](https://github.com/cvilsmeier/go-sqlite-bench) with alternatives.
 
-On BSD Unixes, this module uses
-[BSD locks](https://man.freebsd.org/cgi/man.cgi?query=flock&sektion=2).
-BSD locks may _not_ be compatible with process-associated POSIX advisory locks.
-
-#### Testing
-
-The pure Go VFS is tested by running an unmodified build of SQLite's
-[mptest](https://github.com/sqlite/sqlite/blob/master/mptest/mptest.c)
-on Linux, macOS and Windows.
-Performance is tested by running
+The Wasm and VFS layers are also tested by running SQLite's
 [speedtest1](https://github.com/sqlite/sqlite/blob/master/test/speedtest1.c).
 
-### Roadmap
+### FAQ, issues, new features
 
-- [ ] advanced SQLite features
-  - [x] custom functions
-  - [x] nested transactions
-  - [x] incremental BLOB I/O
-  - [x] online backup
-  - [ ] session extension
-- [ ] custom VFSes
-  - [x] custom VFS API
-  - [x] in-memory VFS
-  - [x] read-only VFS, wrapping an [`io.ReaderAt`](https://pkg.go.dev/io#ReaderAt)
-  - [ ] cloud-based VFS, based on [Cloud Backed SQLite](https://sqlite.org/cloudsqlite/doc/trunk/www/index.wiki)
+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 we want fixed,
+and features we're working on, planning to work on, or asking for help with.
 
 ### Alternatives
 
 - [`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)
+- [`github.com/zombiezen/go-sqlite`](https://pkg.go.dev/github.com/zombiezen/go-sqlite)

backup.go

@@ -2,7 +2,7 @@ package sqlite3
 
 // Backup is an handle to an ongoing online backup operation.
 //
-// https://www.sqlite.org/c3ref/backup.html
+// https://sqlite.org/c3ref/backup.html
 type Backup struct {
 	c      *Conn
 	handle uint32
@@ -15,7 +15,7 @@ type Backup struct {
 // and blocks until the entire backup is complete.
 // Use [Conn.BackupInit] for incremental backup.
 //
-// https://www.sqlite.org/backup.html
+// https://sqlite.org/backup.html
 func (src *Conn) Backup(srcDB, dstURI string) error {
 	b, err := src.BackupInit(srcDB, dstURI)
 	if err != nil {
@@ -31,7 +31,7 @@ func (src *Conn) Backup(srcDB, dstURI string) error {
 // Restore opens the SQLite database file srcURI,
 // and blocks until the entire restore is complete.
 //
-// https://www.sqlite.org/backup.html
+// https://sqlite.org/backup.html
 func (dst *Conn) Restore(dstDB, srcURI string) error {
 	src, err := dst.openDB(srcURI, OPEN_READONLY|OPEN_URI)
 	if err != nil {
@@ -52,7 +52,7 @@ func (dst *Conn) Restore(dstDB, srcURI string) error {
 // then initializes a backup that copies the contents of srcDB on the src connection
 // to the "main" database in dstURI.
 //
-// https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupinit
+// https://sqlite.org/c3ref/backup_finish.html#sqlite3backupinit
 func (src *Conn) BackupInit(srcDB, dstURI string) (*Backup, error) {
 	dst, err := src.openDB(dstURI, OPEN_READWRITE|OPEN_CREATE|OPEN_URI)
 	if err != nil {
@@ -62,7 +62,7 @@ func (src *Conn) BackupInit(srcDB, dstURI string) (*Backup, error) {
 }
 
 func (c *Conn) backupInit(dst uint32, dstName string, src uint32, srcName string) (*Backup, error) {
-	defer c.arena.reset()
+	defer c.arena.mark()()
 	dstPtr := c.arena.string(dstName)
 	srcPtr := c.arena.string(srcName)
 
@@ -71,12 +71,12 @@ func (c *Conn) backupInit(dst uint32, dstName string, src uint32, srcName string
 		other = src
 	}
 
-	r := c.call(c.api.backupInit,
+	r := c.call("sqlite3_backup_init",
 		uint64(dst), uint64(dstPtr),
 		uint64(src), uint64(srcPtr))
 	if r == 0 {
 		defer c.closeDB(other)
-		r = c.call(c.api.errcode, uint64(dst))
+		r = c.call("sqlite3_errcode", uint64(dst))
 		return nil, c.sqlite.error(r, dst)
 	}
 
@@ -91,13 +91,13 @@ func (c *Conn) backupInit(dst uint32, dstName string, src uint32, srcName string
 //
 // It is safe to close a nil, zero or closed Backup.
 //
-// https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupfinish
+// https://sqlite.org/c3ref/backup_finish.html#sqlite3backupfinish
 func (b *Backup) Close() error {
 	if b == nil || b.handle == 0 {
 		return nil
 	}
 
-	r := b.c.call(b.c.api.backupFinish, uint64(b.handle))
+	r := b.c.call("sqlite3_backup_finish", uint64(b.handle))
 	b.c.closeDB(b.otherc)
 	b.handle = 0
 	return b.c.error(r)
@@ -106,9 +106,9 @@ func (b *Backup) Close() error {
 // Step copies up to nPage pages between the source and destination databases.
 // If nPage is negative, all remaining source pages are copied.
 //
-// https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupstep
+// https://sqlite.org/c3ref/backup_finish.html#sqlite3backupstep
 func (b *Backup) Step(nPage int) (done bool, err error) {
-	r := b.c.call(b.c.api.backupStep, uint64(b.handle), uint64(nPage))
+	r := b.c.call("sqlite3_backup_step", uint64(b.handle), uint64(nPage))
 	if r == _DONE {
 		return true, nil
 	}
@@ -118,17 +118,17 @@ func (b *Backup) Step(nPage int) (done bool, err error) {
 // Remaining returns the number of pages still to be backed up
 // at the conclusion of the most recent [Backup.Step].
 //
-// https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupremaining
+// https://sqlite.org/c3ref/backup_finish.html#sqlite3backupremaining
 func (b *Backup) Remaining() int {
-	r := b.c.call(b.c.api.backupRemaining, uint64(b.handle))
-	return int(r)
+	r := b.c.call("sqlite3_backup_remaining", uint64(b.handle))
+	return int(int32(r))
 }
 
 // PageCount returns the total number of pages in the source database
 // at the conclusion of the most recent [Backup.Step].
 //
-// https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backuppagecount
+// https://sqlite.org/c3ref/backup_finish.html#sqlite3backuppagecount
 func (b *Backup) PageCount() int {
-	r := b.c.call(b.c.api.backupPageCount, uint64(b.handle))
-	return int(r)
+	r := b.c.call("sqlite3_backup_pagecount", uint64(b.handle))
+	return int(int32(r))
 }

blob.go

@@ -15,22 +15,23 @@ type ZeroBlob int64
 //
 // It implements [io.ReadWriteSeeker] for incremental BLOB I/O.
 //
-// https://www.sqlite.org/c3ref/blob.html
+// https://sqlite.org/c3ref/blob.html
 type Blob struct {
 	c      *Conn
 	bytes  int64
 	offset int64
 	handle uint32
+	bufptr uint32
+	buflen int64
 }
 
 var _ io.ReadWriteSeeker = &Blob{}
 
 // OpenBlob opens a BLOB for incremental I/O.
 //
-// https://www.sqlite.org/c3ref/blob_open.html
+// https://sqlite.org/c3ref/blob_open.html
 func (c *Conn) OpenBlob(db, table, column string, row int64, write bool) (*Blob, error) {
-	c.checkInterrupt()
-	defer c.arena.reset()
+	defer c.arena.mark()()
 	blobPtr := c.arena.new(ptrlen)
 	dbPtr := c.arena.string(db)
 	tablePtr := c.arena.string(table)
@@ -41,7 +42,8 @@ func (c *Conn) OpenBlob(db, table, column string, row int64, write bool) (*Blob,
 		flags = 1
 	}
 
-	r := c.call(c.api.blobOpen, uint64(c.handle),
+	c.checkInterrupt(c.handle)
+	r := c.call("sqlite3_blob_open", uint64(c.handle),
 		uint64(dbPtr), uint64(tablePtr), uint64(columnPtr),
 		uint64(row), flags, uint64(blobPtr))
 
@@ -51,7 +53,7 @@ func (c *Conn) OpenBlob(db, table, column string, row int64, write bool) (*Blob,
 
 	blob := Blob{c: c}
 	blob.handle = util.ReadUint32(c.mod, blobPtr)
-	blob.bytes = int64(c.call(c.api.blobBytes, uint64(blob.handle)))
+	blob.bytes = int64(c.call("sqlite3_blob_bytes", uint64(blob.handle)))
 	return &blob, nil
 }
 
@@ -59,44 +61,45 @@ func (c *Conn) OpenBlob(db, table, column string, row int64, write bool) (*Blob,
 //
 // It is safe to close a nil, zero or closed Blob.
 //
-// https://www.sqlite.org/c3ref/blob_close.html
+// https://sqlite.org/c3ref/blob_close.html
 func (b *Blob) Close() error {
 	if b == nil || b.handle == 0 {
 		return nil
 	}
 
-	r := b.c.call(b.c.api.blobClose, uint64(b.handle))
-
+	r := b.c.call("sqlite3_blob_close", uint64(b.handle))
+	b.c.free(b.bufptr)
 	b.handle = 0
 	return b.c.error(r)
 }
 
 // Size returns the size of the BLOB in bytes.
 //
-// https://www.sqlite.org/c3ref/blob_bytes.html
+// https://sqlite.org/c3ref/blob_bytes.html
 func (b *Blob) Size() int64 {
 	return b.bytes
 }
 
 // Read implements the [io.Reader] interface.
 //
-// https://www.sqlite.org/c3ref/blob_read.html
+// https://sqlite.org/c3ref/blob_read.html
 func (b *Blob) Read(p []byte) (n int, err error) {
 	if b.offset >= b.bytes {
 		return 0, io.EOF
 	}
 
-	avail := b.bytes - b.offset
 	want := int64(len(p))
+	avail := b.bytes - b.offset
 	if want > avail {
 		want = avail
 	}
+	if want > b.buflen {
+		b.bufptr = b.c.realloc(b.bufptr, uint64(want))
+		b.buflen = want
+	}
 
-	defer b.c.arena.reset()
-	ptr := b.c.arena.new(uint64(want))
-
-	r := b.c.call(b.c.api.blobRead, uint64(b.handle),
-		uint64(ptr), uint64(want), uint64(b.offset))
+	r := b.c.call("sqlite3_blob_read", uint64(b.handle),
+		uint64(b.bufptr), uint64(want), uint64(b.offset))
 	err = b.c.error(r)
 	if err != nil {
 		return 0, err
@@ -106,36 +109,37 @@ func (b *Blob) Read(p []byte) (n int, err error) {
 		err = io.EOF
 	}
 
-	copy(p, util.View(b.c.mod, ptr, uint64(want)))
+	copy(p, util.View(b.c.mod, b.bufptr, uint64(want)))
 	return int(want), err
 }
 
 // WriteTo implements the [io.WriterTo] interface.
 //
-// https://www.sqlite.org/c3ref/blob_read.html
+// https://sqlite.org/c3ref/blob_read.html
 func (b *Blob) WriteTo(w io.Writer) (n int64, err error) {
 	if b.offset >= b.bytes {
 		return 0, nil
 	}
 
+	want := int64(1024 * 1024)
 	avail := b.bytes - b.offset
-	want := int64(65536)
 	if want > avail {
 		want = avail
 	}
-
-	ptr := b.c.new(uint64(want))
-	defer b.c.free(ptr)
+	if want > b.buflen {
+		b.bufptr = b.c.realloc(b.bufptr, uint64(want))
+		b.buflen = want
+	}
 
 	for want > 0 {
-		r := b.c.call(b.c.api.blobRead, uint64(b.handle),
-			uint64(ptr), uint64(want), uint64(b.offset))
+		r := b.c.call("sqlite3_blob_read", uint64(b.handle),
+			uint64(b.bufptr), uint64(want), uint64(b.offset))
 		err = b.c.error(r)
 		if err != nil {
 			return n, err
 		}
 
-		mem := util.View(b.c.mod, ptr, uint64(want))
+		mem := util.View(b.c.mod, b.bufptr, uint64(want))
 		m, err := w.Write(mem[:want])
 		b.offset += int64(m)
 		n += int64(m)
@@ -143,6 +147,7 @@ func (b *Blob) WriteTo(w io.Writer) (n int64, err error) {
 			return n, err
 		}
 		if int64(m) != want {
+			// notest // Write misbehaving
 			return n, io.ErrShortWrite
 		}
 
@@ -156,13 +161,17 @@ func (b *Blob) WriteTo(w io.Writer) (n int64, err error) {
 
 // Write implements the [io.Writer] interface.
 //
-// https://www.sqlite.org/c3ref/blob_write.html
+// https://sqlite.org/c3ref/blob_write.html
 func (b *Blob) Write(p []byte) (n int, err error) {
-	defer b.c.arena.reset()
-	ptr := b.c.arena.bytes(p)
+	want := int64(len(p))
+	if want > b.buflen {
+		b.bufptr = b.c.realloc(b.bufptr, uint64(want))
+		b.buflen = want
+	}
+	util.WriteBytes(b.c.mod, b.bufptr, p)
 
-	r := b.c.call(b.c.api.blobWrite, uint64(b.handle),
-		uint64(ptr), uint64(len(p)), uint64(b.offset))
+	r := b.c.call("sqlite3_blob_write", uint64(b.handle),
+		uint64(b.bufptr), uint64(want), uint64(b.offset))
 	err = b.c.error(r)
 	if err != nil {
 		return 0, err
@@ -173,26 +182,30 @@ func (b *Blob) Write(p []byte) (n int, err error) {
 
 // ReadFrom implements the [io.ReaderFrom] interface.
 //
-// https://www.sqlite.org/c3ref/blob_write.html
+// https://sqlite.org/c3ref/blob_write.html
 func (b *Blob) ReadFrom(r io.Reader) (n int64, err error) {
+	want := int64(1024 * 1024)
 	avail := b.bytes - b.offset
-	want := int64(65536)
+	if l, ok := r.(*io.LimitedReader); ok && want > l.N {
+		want = l.N
+	}
 	if want > avail {
 		want = avail
 	}
 	if want < 1 {
 		want = 1
 	}
-
-	ptr := b.c.new(uint64(want))
-	defer b.c.free(ptr)
+	if want > b.buflen {
+		b.bufptr = b.c.realloc(b.bufptr, uint64(want))
+		b.buflen = want
+	}
 
 	for {
-		mem := util.View(b.c.mod, ptr, uint64(want))
+		mem := util.View(b.c.mod, b.bufptr, uint64(want))
 		m, err := r.Read(mem[:want])
 		if m > 0 {
-			r := b.c.call(b.c.api.blobWrite, uint64(b.handle),
-				uint64(ptr), uint64(m), uint64(b.offset))
+			r := b.c.call("sqlite3_blob_write", uint64(b.handle),
+				uint64(b.bufptr), uint64(m), uint64(b.offset))
 			err := b.c.error(r)
 			if err != nil {
 				return n, err
@@ -238,10 +251,11 @@ func (b *Blob) Seek(offset int64, whence int) (int64, error) {
 
 // Reopen moves a BLOB handle to a new row of the same database table.
 //
-// https://www.sqlite.org/c3ref/blob_reopen.html
+// https://sqlite.org/c3ref/blob_reopen.html
 func (b *Blob) Reopen(row int64) error {
-	err := b.c.error(b.c.call(b.c.api.blobReopen, uint64(b.handle), uint64(row)))
-	b.bytes = int64(b.c.call(b.c.api.blobBytes, uint64(b.handle)))
+	b.c.checkInterrupt(b.c.handle)
+	err := b.c.error(b.c.call("sqlite3_blob_reopen", uint64(b.handle), uint64(row)))
+	b.bytes = int64(b.c.call("sqlite3_blob_bytes", uint64(b.handle)))
 	b.offset = 0
 	return err
 }

config.go

@@ -0,0 +1,383 @@
+package sqlite3
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/tetratelabs/wazero/api"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/ncruces/go-sqlite3/vfs"
+)
+
+// Config makes configuration changes to a database connection.
+// Only boolean configuration options are supported.
+// Called with no arg reads the current configuration value,
+// called with one arg sets and returns the new value.
+//
+// https://sqlite.org/c3ref/db_config.html
+func (c *Conn) Config(op DBConfig, arg ...bool) (bool, error) {
+	if op < DBCONFIG_ENABLE_FKEY || op > DBCONFIG_REVERSE_SCANORDER {
+		return false, MISUSE
+	}
+
+	// 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 int
+	switch {
+	case len(arg) == 0:
+		flag = -1
+	case arg[0]:
+		flag = 1
+	}
+
+	util.WriteUint32(c.mod, argsPtr+0*ptrlen, uint32(flag))
+	util.WriteUint32(c.mod, argsPtr+1*ptrlen, argsPtr)
+
+	r := c.call("sqlite3_db_config", uint64(c.handle),
+		uint64(op), uint64(argsPtr))
+	return util.ReadUint32(c.mod, argsPtr) != 0, c.error(r)
+}
+
+// ConfigLog sets up the error logging callback for the connection.
+//
+// https://sqlite.org/errlog.html
+func (c *Conn) ConfigLog(cb func(code ExtendedErrorCode, msg string)) error {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	r := c.call("sqlite3_config_log_go", enable)
+	if err := c.error(r); err != nil {
+		return err
+	}
+	c.log = cb
+	return nil
+}
+
+func logCallback(ctx context.Context, mod api.Module, _, iCode, zMsg uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.log != nil {
+		msg := util.ReadString(mod, zMsg, _MAX_LENGTH)
+		c.log(xErrorCode(iCode), msg)
+	}
+}
+
+// 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()()
+	ptr := c.arena.new(max(ptrlen, intlen))
+
+	var schemaPtr uint32
+	if schema != "" {
+		schemaPtr = c.arena.string(schema)
+	}
+
+	var rc uint64
+	var res any
+	switch op {
+	default:
+		return nil, MISUSE
+
+	case FCNTL_RESET_CACHE:
+		rc = c.call("sqlite3_file_control",
+			uint64(c.handle), uint64(schemaPtr),
+			uint64(op), 0)
+
+	case FCNTL_PERSIST_WAL, FCNTL_POWERSAFE_OVERWRITE:
+		var flag int
+		switch {
+		case len(arg) == 0:
+			flag = -1
+		case arg[0]:
+			flag = 1
+		}
+		util.WriteUint32(c.mod, ptr, uint32(flag))
+		rc = c.call("sqlite3_file_control",
+			uint64(c.handle), uint64(schemaPtr),
+			uint64(op), uint64(ptr))
+		res = util.ReadUint32(c.mod, ptr) != 0
+
+	case FCNTL_CHUNK_SIZE:
+		util.WriteUint32(c.mod, ptr, uint32(arg[0].(int)))
+		rc = c.call("sqlite3_file_control",
+			uint64(c.handle), uint64(schemaPtr),
+			uint64(op), uint64(ptr))
+
+	case FCNTL_RESERVE_BYTES:
+		bytes := -1
+		if len(arg) > 0 {
+			bytes = arg[0].(int)
+		}
+		util.WriteUint32(c.mod, ptr, uint32(bytes))
+		rc = c.call("sqlite3_file_control",
+			uint64(c.handle), uint64(schemaPtr),
+			uint64(op), uint64(ptr))
+		res = int(util.ReadUint32(c.mod, ptr))
+
+	case FCNTL_DATA_VERSION:
+		rc = c.call("sqlite3_file_control",
+			uint64(c.handle), uint64(schemaPtr),
+			uint64(op), uint64(ptr))
+		res = util.ReadUint32(c.mod, ptr)
+
+	case FCNTL_LOCKSTATE:
+		rc = c.call("sqlite3_file_control",
+			uint64(c.handle), uint64(schemaPtr),
+			uint64(op), uint64(ptr))
+		res = vfs.LockLevel(util.ReadUint32(c.mod, ptr))
+
+	case FCNTL_VFS_POINTER:
+		rc = c.call("sqlite3_file_control",
+			uint64(c.handle), uint64(schemaPtr),
+			uint64(op), uint64(ptr))
+		if rc == _OK {
+			const zNameOffset = 16
+			ptr = util.ReadUint32(c.mod, ptr)
+			ptr = util.ReadUint32(c.mod, ptr+zNameOffset)
+			name := util.ReadString(c.mod, ptr, _MAX_NAME)
+			res = vfs.Find(name)
+		}
+
+	case FCNTL_FILE_POINTER, FCNTL_JOURNAL_POINTER:
+		rc = c.call("sqlite3_file_control",
+			uint64(c.handle), uint64(schemaPtr),
+			uint64(op), uint64(ptr))
+		if rc == _OK {
+			const fileHandleOffset = 4
+			ptr = util.ReadUint32(c.mod, ptr)
+			ptr = util.ReadUint32(c.mod, ptr+fileHandleOffset)
+			res = util.GetHandle(c.ctx, ptr)
+		}
+	}
+
+	if err := c.error(rc); err != nil {
+		return nil, err
+	}
+	return res, nil
+}
+
+// Limit allows the size of various constructs to be
+// limited on a connection by connection basis.
+//
+// https://sqlite.org/c3ref/limit.html
+func (c *Conn) Limit(id LimitCategory, value int) int {
+	r := c.call("sqlite3_limit", uint64(c.handle), uint64(id), uint64(value))
+	return int(int32(r))
+}
+
+// SetAuthorizer registers an authorizer callback with the database connection.
+//
+// https://sqlite.org/c3ref/set_authorizer.html
+func (c *Conn) SetAuthorizer(cb func(action AuthorizerActionCode, name3rd, name4th, schema, inner string) AuthorizerReturnCode) error {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	r := c.call("sqlite3_set_authorizer_go", uint64(c.handle), enable)
+	if err := c.error(r); err != nil {
+		return err
+	}
+	c.authorizer = cb
+	return nil
+
+}
+
+func authorizerCallback(ctx context.Context, mod api.Module, pDB uint32, action AuthorizerActionCode, zName3rd, zName4th, zSchema, zInner uint32) (rc AuthorizerReturnCode) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.authorizer != nil {
+		var name3rd, name4th, schema, inner string
+		if zName3rd != 0 {
+			name3rd = util.ReadString(mod, zName3rd, _MAX_NAME)
+		}
+		if zName4th != 0 {
+			name4th = util.ReadString(mod, zName4th, _MAX_NAME)
+		}
+		if zSchema != 0 {
+			schema = util.ReadString(mod, zSchema, _MAX_NAME)
+		}
+		if zInner != 0 {
+			inner = util.ReadString(mod, zInner, _MAX_NAME)
+		}
+		rc = c.authorizer(action, name3rd, name4th, schema, inner)
+	}
+	return rc
+}
+
+// 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 {
+		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 {
+		var arg1, arg2 any
+		if evt == TRACE_CLOSE {
+			arg1 = c
+		} else {
+			for _, s := range c.stmts {
+				if pArg1 == s.handle {
+					arg1 = s
+					switch evt {
+					case TRACE_STMT:
+						arg2 = s.SQL()
+					case TRACE_PROFILE:
+						arg2 = int64(util.ReadUint64(mod, pArg2))
+					}
+					break
+				}
+			}
+		}
+		if arg1 != nil {
+			_, rc = errorCode(c.trace(evt, arg1, arg2), ERROR)
+		}
+	}
+	return rc
+}
+
+// WALCheckpoint checkpoints a WAL database.
+//
+// https://sqlite.org/c3ref/wal_checkpoint_v2.html
+func (c *Conn) WALCheckpoint(schema string, mode CheckpointMode) (nLog, nCkpt int, err error) {
+	defer c.arena.mark()()
+	nLogPtr := c.arena.new(ptrlen)
+	nCkptPtr := c.arena.new(ptrlen)
+	schemaPtr := c.arena.string(schema)
+	r := c.call("sqlite3_wal_checkpoint_v2",
+		uint64(c.handle), uint64(schemaPtr), uint64(mode),
+		uint64(nLogPtr), uint64(nCkptPtr))
+	nLog = int(int32(util.ReadUint32(c.mod, nLogPtr)))
+	nCkpt = int(int32(util.ReadUint32(c.mod, nCkptPtr)))
+	return nLog, nCkpt, c.error(r)
+}
+
+// WALAutoCheckpoint configures WAL auto-checkpoints.
+//
+// https://sqlite.org/c3ref/wal_autocheckpoint.html
+func (c *Conn) WALAutoCheckpoint(pages int) error {
+	r := c.call("sqlite3_wal_autocheckpoint", uint64(c.handle), uint64(pages))
+	return c.error(r)
+}
+
+// WALHook registers a callback function to be invoked
+// each time data is committed to a database in WAL mode.
+//
+// https://sqlite.org/c3ref/wal_hook.html
+func (c *Conn) WALHook(cb func(db *Conn, schema string, pages int) error) {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	c.call("sqlite3_wal_hook_go", uint64(c.handle), enable)
+	c.wal = cb
+}
+
+func walCallback(ctx context.Context, mod api.Module, _, pDB, zSchema uint32, pages int32) (rc uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.wal != nil {
+		schema := util.ReadString(mod, zSchema, _MAX_NAME)
+		err := c.wal(c, schema, int(pages))
+		_, rc = errorCode(err, ERROR)
+	}
+	return rc
+}
+
+// AutoVacuumPages registers a autovacuum compaction amount callback.
+//
+// https://sqlite.org/c3ref/autovacuum_pages.html
+func (c *Conn) AutoVacuumPages(cb func(schema string, dbPages, freePages, bytesPerPage uint) uint) error {
+	var funcPtr uint32
+	if cb != nil {
+		funcPtr = util.AddHandle(c.ctx, cb)
+	}
+	r := c.call("sqlite3_autovacuum_pages_go", uint64(c.handle), uint64(funcPtr))
+	return c.error(r)
+}
+
+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)))
+}
+
+// SoftHeapLimit imposes a soft limit on heap size.
+//
+// https://sqlite.org/c3ref/hard_heap_limit64.html
+func (c *Conn) SoftHeapLimit(n int64) int64 {
+	return int64(c.call("sqlite3_soft_heap_limit64", uint64(n)))
+}
+
+// HardHeapLimit imposes a hard limit on heap size.
+//
+// https://sqlite.org/c3ref/hard_heap_limit64.html
+func (c *Conn) HardHeapLimit(n int64) int64 {
+	return int64(c.call("sqlite3_hard_heap_limit64", uint64(n)))
+}
+
+// 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 util.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_RESTART)
+	return err
+}

conn.go

@@ -2,69 +2,100 @@ package sqlite3
 
 import (
 	"context"
-	"database/sql/driver"
-	"errors"
 	"fmt"
+	"math"
+	"math/rand"
 	"net/url"
 	"runtime"
 	"strings"
-	"sync/atomic"
-	"unsafe"
+	"time"
+
+	"github.com/tetratelabs/wazero/api"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/ncruces/go-sqlite3/vfs"
 )
 
 // Conn is a database connection handle.
 // A Conn is not safe for concurrent use by multiple goroutines.
 //
-// https://www.sqlite.org/c3ref/sqlite3.html
+// https://sqlite.org/c3ref/sqlite3.html
 type Conn struct {
 	*sqlite
 
-	interrupt context.Context
-	waiter    chan struct{}
-	pending   *Stmt
-	arena     arena
+	interrupt  context.Context
+	pending    *Stmt
+	stmts      []*Stmt
+	busy       func(context.Context, int) bool
+	log        func(xErrorCode, string)
+	collation  func(*Conn, string)
+	wal        func(*Conn, string, int) error
+	trace      func(TraceEvent, any, any) error
+	authorizer func(AuthorizerActionCode, string, string, string, string) AuthorizerReturnCode
+	update     func(AuthorizerActionCode, string, string, int64)
+	commit     func() bool
+	rollback   func()
+	arena      arena
 
-	handle uint32
+	busy1st time.Time
+	busylst time.Time
+	handle  uint32
 }
 
-// Open calls [OpenFlags] with [OPEN_READWRITE], [OPEN_CREATE], [OPEN_URI] and [OPEN_NOFOLLOW].
+// Open calls [OpenFlags] with [OPEN_READWRITE], [OPEN_CREATE] and [OPEN_URI].
 func Open(filename string) (*Conn, error) {
-	return newConn(filename, OPEN_READWRITE|OPEN_CREATE|OPEN_URI|OPEN_NOFOLLOW)
+	return newConn(context.Background(), filename, OPEN_READWRITE|OPEN_CREATE|OPEN_URI)
+}
+
+// OpenContext is like [Open] but includes a context,
+// which is used to interrupt the process of opening the connectiton.
+func OpenContext(ctx context.Context, filename string) (*Conn, error) {
+	return newConn(ctx, filename, OPEN_READWRITE|OPEN_CREATE|OPEN_URI)
 }
 
 // OpenFlags opens an SQLite database file as specified by the filename argument.
 //
-// If none of the required flags is used, a combination of [OPEN_READWRITE] and [OPEN_CREATE] is used.
+// If none of the required flags are used, a combination of [OPEN_READWRITE] and [OPEN_CREATE] is used.
 // If a URI filename is used, PRAGMA statements to execute can be specified using "_pragma":
 //
 //	sqlite3.Open("file:demo.db?_pragma=busy_timeout(10000)")
 //
-// https://www.sqlite.org/c3ref/open.html
+// https://sqlite.org/c3ref/open.html
 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)
 }
 
-func newConn(filename string, flags OpenFlag) (conn *Conn, err error) {
-	sqlite, err := instantiateSQLite()
+type connKey = util.ConnKey
+
+func newConn(ctx context.Context, filename string, flags OpenFlag) (res *Conn, _ error) {
+	err := ctx.Err()
+	if err != nil {
+		return nil, err
+	}
+
+	c := &Conn{interrupt: ctx}
+	c.sqlite, err = instantiateSQLite()
 	if err != nil {
 		return nil, err
 	}
 	defer func() {
-		if conn == nil {
-			sqlite.close()
+		if res == nil {
+			c.Close()
+			c.sqlite.close()
 		} else {
-			runtime.SetFinalizer(conn, util.Finalizer[Conn](3))
+			c.interrupt = context.Background()
 		}
 	}()
 
-	c := &Conn{sqlite: sqlite}
+	c.ctx = context.WithValue(c.ctx, connKey{}, c)
 	c.arena = c.newArena(1024)
 	c.handle, err = c.openDB(filename, flags)
+	if err == nil {
+		err = initExtensions(c)
+	}
 	if err != nil {
 		return nil, err
 	}
@@ -72,12 +103,12 @@ func newConn(filename string, flags OpenFlag) (conn *Conn, err error) {
 }
 
 func (c *Conn) openDB(filename string, flags OpenFlag) (uint32, error) {
-	defer c.arena.reset()
+	defer c.arena.mark()()
 	connPtr := c.arena.new(ptrlen)
 	namePtr := c.arena.string(filename)
 
 	flags |= OPEN_EXRESCODE
-	r := c.call(c.api.open, uint64(namePtr), uint64(connPtr), uint64(flags), 0)
+	r := c.call("sqlite3_open_v2", uint64(namePtr), uint64(connPtr), uint64(flags), 0)
 
 	handle := util.ReadUint32(c.mod, connPtr)
 	if err := c.sqlite.error(r, handle); err != nil {
@@ -85,6 +116,7 @@ func (c *Conn) openDB(filename string, flags OpenFlag) (uint32, error) {
 		return 0, err
 	}
 
+	c.call("sqlite3_progress_handler_go", uint64(handle), 100)
 	if flags|OPEN_URI != 0 && strings.HasPrefix(filename, "file:") {
 		var pragmas strings.Builder
 		if _, after, ok := strings.Cut(filename, "?"); ok {
@@ -92,27 +124,25 @@ func (c *Conn) openDB(filename string, flags OpenFlag) (uint32, error) {
 			for _, p := range query["_pragma"] {
 				pragmas.WriteString(`PRAGMA `)
 				pragmas.WriteString(p)
-				pragmas.WriteByte(';')
+				pragmas.WriteString(`;`)
 			}
 		}
-
-		c.arena.reset()
-		pragmaPtr := c.arena.string(pragmas.String())
-		r := c.call(c.api.exec, uint64(handle), uint64(pragmaPtr), 0, 0, 0)
-		if err := c.sqlite.error(r, handle, pragmas.String()); err != nil {
-			if errors.Is(err, ERROR) {
+		if pragmas.Len() != 0 {
+			c.checkInterrupt(handle)
+			pragmaPtr := c.arena.string(pragmas.String())
+			r := c.call("sqlite3_exec", uint64(handle), uint64(pragmaPtr), 0, 0, 0)
+			if err := c.sqlite.error(r, handle, pragmas.String()); err != nil {
 				err = fmt.Errorf("sqlite3: invalid _pragma: %w", err)
+				c.closeDB(handle)
+				return 0, err
 			}
-			c.closeDB(handle)
-			return 0, err
 		}
 	}
-
 	return handle, nil
 }
 
 func (c *Conn) closeDB(handle uint32) {
-	r := c.call(c.api.closeZombie, uint64(handle))
+	r := c.call("sqlite3_close_v2", uint64(handle))
 	if err := c.sqlite.error(r, handle); err != nil {
 		panic(err)
 	}
@@ -126,37 +156,35 @@ func (c *Conn) closeDB(handle uint32) {
 //
 // It is safe to close a nil, zero or closed Conn.
 //
-// https://www.sqlite.org/c3ref/close.html
+// https://sqlite.org/c3ref/close.html
 func (c *Conn) Close() error {
 	if c == nil || c.handle == 0 {
 		return nil
 	}
 
-	c.SetInterrupt(context.Background())
 	c.pending.Close()
 	c.pending = nil
 
-	r := c.call(c.api.close, uint64(c.handle))
+	r := c.call("sqlite3_close", uint64(c.handle))
 	if err := c.error(r); err != nil {
 		return err
 	}
 
 	c.handle = 0
-	runtime.SetFinalizer(c, nil)
 	return c.close()
 }
 
 // Exec is a convenience function that allows an application to run
 // multiple statements of SQL without having to use a lot of code.
 //
-// https://www.sqlite.org/c3ref/exec.html
+// https://sqlite.org/c3ref/exec.html
 func (c *Conn) Exec(sql string) error {
-	c.checkInterrupt()
-	defer c.arena.reset()
+	defer c.arena.mark()()
 	sqlPtr := c.arena.string(sql)
 
-	r := c.call(c.api.exec, uint64(c.handle), uint64(sqlPtr), 0, 0, 0)
-	return c.error(r)
+	c.checkInterrupt(c.handle)
+	r := c.call("sqlite3_exec", uint64(c.handle), uint64(sqlPtr), 0, 0, 0)
+	return c.error(r, sql)
 }
 
 // Prepare calls [Conn.PrepareFlags] with no flags.
@@ -169,25 +197,27 @@ func (c *Conn) Prepare(sql string) (stmt *Stmt, tail string, err error) {
 // If the input text contains no SQL (if the input is an empty string or a comment),
 // both stmt and err will be nil.
 //
-// https://www.sqlite.org/c3ref/prepare.html
+// https://sqlite.org/c3ref/prepare.html
 func (c *Conn) PrepareFlags(sql string, flags PrepareFlag) (stmt *Stmt, tail string, err error) {
-	if emptyStatement(sql) {
-		return nil, "", nil
+	if len(sql) > _MAX_SQL_LENGTH {
+		return nil, "", TOOBIG
 	}
 
-	defer c.arena.reset()
+	defer c.arena.mark()()
 	stmtPtr := c.arena.new(ptrlen)
 	tailPtr := c.arena.new(ptrlen)
 	sqlPtr := c.arena.string(sql)
 
-	r := c.call(c.api.prepare, uint64(c.handle),
+	c.checkInterrupt(c.handle)
+	r := c.call("sqlite3_prepare_v3", uint64(c.handle),
 		uint64(sqlPtr), uint64(len(sql)+1), uint64(flags),
 		uint64(stmtPtr), uint64(tailPtr))
 
 	stmt = &Stmt{c: c}
 	stmt.handle = util.ReadUint32(c.mod, stmtPtr)
-	i := util.ReadUint32(c.mod, tailPtr)
-	tail = sql[i-sqlPtr:]
+	if sql := sql[util.ReadUint32(c.mod, tailPtr)-sqlPtr:]; sql != "" {
+		tail = sql
+	}
 
 	if err := c.error(r, sql); err != nil {
 		return nil, "", err
@@ -195,36 +225,107 @@ func (c *Conn) PrepareFlags(sql string, flags PrepareFlag) (stmt *Stmt, tail str
 	if stmt.handle == 0 {
 		return nil, "", nil
 	}
-	return
+	c.stmts = append(c.stmts, stmt)
+	return stmt, tail, nil
+}
+
+// DBName returns the schema name for n-th database on the database connection.
+//
+// https://sqlite.org/c3ref/db_name.html
+func (c *Conn) DBName(n int) string {
+	r := c.call("sqlite3_db_name", uint64(c.handle), uint64(n))
+
+	ptr := uint32(r)
+	if ptr == 0 {
+		return ""
+	}
+	return util.ReadString(c.mod, ptr, _MAX_NAME)
+}
+
+// Filename returns the filename for a database.
+//
+// https://sqlite.org/c3ref/db_filename.html
+func (c *Conn) Filename(schema string) *vfs.Filename {
+	var ptr uint32
+	if schema != "" {
+		defer c.arena.mark()()
+		ptr = c.arena.string(schema)
+	}
+	r := c.call("sqlite3_db_filename", uint64(c.handle), uint64(ptr))
+	return vfs.GetFilename(c.ctx, c.mod, uint32(r), vfs.OPEN_MAIN_DB)
+}
+
+// ReadOnly determines if a database is read-only.
+//
+// https://sqlite.org/c3ref/db_readonly.html
+func (c *Conn) ReadOnly(schema string) (ro bool, ok bool) {
+	var ptr uint32
+	if schema != "" {
+		defer c.arena.mark()()
+		ptr = c.arena.string(schema)
+	}
+	r := c.call("sqlite3_db_readonly", uint64(c.handle), uint64(ptr))
+	return int32(r) > 0, int32(r) < 0
 }
 
 // GetAutocommit tests the connection for auto-commit mode.
 //
-// https://www.sqlite.org/c3ref/get_autocommit.html
+// https://sqlite.org/c3ref/get_autocommit.html
 func (c *Conn) GetAutocommit() bool {
-	r := c.call(c.api.autocommit, uint64(c.handle))
+	r := c.call("sqlite3_get_autocommit", uint64(c.handle))
 	return r != 0
 }
 
 // LastInsertRowID returns the rowid of the most recent successful INSERT
 // on the database connection.
 //
-// https://www.sqlite.org/c3ref/last_insert_rowid.html
+// https://sqlite.org/c3ref/last_insert_rowid.html
 func (c *Conn) LastInsertRowID() int64 {
-	r := c.call(c.api.lastRowid, uint64(c.handle))
+	r := c.call("sqlite3_last_insert_rowid", uint64(c.handle))
 	return int64(r)
 }
 
+// SetLastInsertRowID allows the application to set the value returned by
+// [Conn.LastInsertRowID].
+//
+// https://sqlite.org/c3ref/set_last_insert_rowid.html
+func (c *Conn) SetLastInsertRowID(id int64) {
+	c.call("sqlite3_set_last_insert_rowid", uint64(c.handle), uint64(id))
+}
+
 // Changes returns the number of rows modified, inserted or deleted
 // by the most recently completed INSERT, UPDATE or DELETE statement
 // on the database connection.
 //
-// https://www.sqlite.org/c3ref/changes.html
+// https://sqlite.org/c3ref/changes.html
 func (c *Conn) Changes() int64 {
-	r := c.call(c.api.changes, uint64(c.handle))
+	r := c.call("sqlite3_changes64", uint64(c.handle))
 	return int64(r)
 }
 
+// TotalChanges returns the number of rows modified, inserted or deleted
+// by all INSERT, UPDATE or DELETE statements completed
+// since the database connection was opened.
+//
+// https://sqlite.org/c3ref/total_changes.html
+func (c *Conn) TotalChanges() int64 {
+	r := c.call("sqlite3_total_changes64", uint64(c.handle))
+	return int64(r)
+}
+
+// ReleaseMemory frees memory used by a database connection.
+//
+// https://sqlite.org/c3ref/db_release_memory.html
+func (c *Conn) ReleaseMemory() error {
+	r := c.call("sqlite3_db_release_memory", uint64(c.handle))
+	return c.error(r)
+}
+
+// GetInterrupt gets the context set with [Conn.SetInterrupt].
+func (c *Conn) GetInterrupt() context.Context {
+	return c.interrupt
+}
+
 // SetInterrupt interrupts a long-running query when a context is done.
 //
 // Subsequent uses of the connection will return [INTERRUPT]
@@ -238,108 +339,179 @@ func (c *Conn) Changes() int64 {
 //
 // SetInterrupt returns the old context assigned to the connection.
 //
-// https://www.sqlite.org/c3ref/interrupt.html
+// https://sqlite.org/c3ref/interrupt.html
 func (c *Conn) SetInterrupt(ctx context.Context) (old context.Context) {
-	// Is a waiter running?
-	if c.waiter != nil {
-		c.waiter <- struct{}{} // Cancel the waiter.
-		<-c.waiter             // Wait for it to finish.
-		c.waiter = nil
-	}
-	// Reset the pending statement.
-	if c.pending != nil {
-		c.pending.Reset()
-	}
-
 	old = c.interrupt
 	c.interrupt = ctx
-	if ctx == nil || ctx.Done() == nil {
+
+	if ctx == old || ctx.Done() == old.Done() {
 		return old
 	}
 
-	// Creating an uncompleted SQL statement prevents SQLite from ignoring
-	// an interrupt that comes before any other statements are started.
+	// A busy SQL statement prevents SQLite from ignoring an interrupt
+	// that comes before any other statements are started.
 	if c.pending == nil {
-		c.pending, _, _ = c.Prepare(`SELECT 1 UNION ALL SELECT 2`)
-	}
-	c.pending.Step()
-
-	// Don't create the goroutine if we're already interrupted.
-	// This happens frequently while restoring to a previously interrupted state.
-	if c.checkInterrupt() {
-		return old
+		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,
+			uint64(PREPARE_PERSISTENT), uint64(stmtPtr), 0)
+		c.pending = &Stmt{c: c}
+		c.pending.handle = util.ReadUint32(c.mod, stmtPtr)
 	}
 
-	waiter := make(chan struct{})
-	c.waiter = waiter
-	go func() {
-		select {
-		case <-waiter: // Waiter was cancelled.
-			break
-
-		case <-ctx.Done(): // Done was closed.
-			const isInterruptedOffset = 288
-			buf := util.View(c.mod, c.handle+isInterruptedOffset, 4)
-			(*atomic.Uint32)(unsafe.Pointer(&buf[0])).Store(1)
-			// Wait for the next call to SetInterrupt.
-			<-waiter
-		}
-
-		// Signal that the waiter has finished.
-		waiter <- struct{}{}
-	}()
+	if old.Done() != nil && ctx.Err() == nil {
+		c.pending.Reset()
+	}
+	if ctx.Done() != nil {
+		c.pending.Step()
+	}
 	return old
 }
 
-func (c *Conn) checkInterrupt() bool {
-	if c.interrupt == nil || c.interrupt.Err() == nil {
-		return false
+func (c *Conn) checkInterrupt(handle uint32) {
+	if c.interrupt.Err() != nil {
+		c.call("sqlite3_interrupt", uint64(handle))
 	}
-	const isInterruptedOffset = 288
-	buf := util.View(c.mod, c.handle+isInterruptedOffset, 4)
-	(*atomic.Uint32)(unsafe.Pointer(&buf[0])).Store(1)
-	return true
 }
 
-// Pragma executes a PRAGMA statement and returns any results.
-//
-// https://www.sqlite.org/pragma.html
-func (c *Conn) Pragma(str string) ([]string, error) {
-	stmt, _, err := c.Prepare(`PRAGMA ` + str)
-	if err != nil {
-		return nil, err
+func progressCallback(ctx context.Context, mod api.Module, _ uint32) (interrupt uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok {
+		if c.interrupt.Done() != nil {
+			runtime.Gosched()
+		}
+		if c.interrupt.Err() != nil {
+			interrupt = 1
+		}
 	}
-	defer stmt.Close()
+	return interrupt
+}
 
-	var pragmas []string
-	for stmt.Step() {
-		pragmas = append(pragmas, stmt.ColumnText(0))
+// BusyTimeout sets a busy timeout.
+//
+// https://sqlite.org/c3ref/busy_timeout.html
+func (c *Conn) BusyTimeout(timeout time.Duration) error {
+	ms := min((timeout+time.Millisecond-1)/time.Millisecond, math.MaxInt32)
+	r := c.call("sqlite3_busy_timeout", uint64(c.handle), uint64(ms))
+	return c.error(r)
+}
+
+func timeoutCallback(ctx context.Context, mod api.Module, count, tmout int32) (retry uint32) {
+	// https://fractaledmind.github.io/2024/04/15/sqlite-on-rails-the-how-and-why-of-optimal-performance/
+	if c, ok := ctx.Value(connKey{}).(*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 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 pragmas, stmt.Close()
+	return 0
+}
+
+// BusyHandler registers a callback to handle [BUSY] errors.
+//
+// https://sqlite.org/c3ref/busy_handler.html
+func (c *Conn) BusyHandler(cb func(ctx context.Context, count int) (retry bool)) error {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	r := c.call("sqlite3_busy_handler_go", uint64(c.handle), enable)
+	if err := c.error(r); err != nil {
+		return err
+	}
+	c.busy = cb
+	return nil
+}
+
+func busyCallback(ctx context.Context, mod api.Module, pDB uint32, count int32) (retry uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.busy != nil {
+		interrupt := c.interrupt
+		if interrupt == nil {
+			interrupt = context.Background()
+		}
+		if interrupt.Err() == nil && c.busy(interrupt, int(count)) {
+			retry = 1
+		}
+	}
+	return retry
+}
+
+// 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(intlen)
+	curPtr := c.arena.new(intlen)
+
+	var i uint64
+	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))
+	}
+	return
+}
+
+// TableColumnMetadata extracts metadata about a column of a table.
+//
+// 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)
+	autoIncPtr := c.arena.new(ptrlen)
+	primaryKeyPtr := c.arena.new(ptrlen)
+	if schema != "" {
+		schemaPtr = c.arena.string(schema)
+	}
+	tablePtr := c.arena.string(table)
+	if column != "" {
+		columnPtr = c.arena.string(column)
+	}
+
+	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 != "" {
+		if ptr := util.ReadUint32(c.mod, declTypePtr); ptr != 0 {
+			declType = util.ReadString(c.mod, ptr, _MAX_NAME)
+		}
+		if ptr := util.ReadUint32(c.mod, collSeqPtr); ptr != 0 {
+			collSeq = util.ReadString(c.mod, ptr, _MAX_NAME)
+		}
+		notNull = util.ReadUint32(c.mod, notNullPtr) != 0
+		autoInc = util.ReadUint32(c.mod, autoIncPtr) != 0
+		primaryKey = util.ReadUint32(c.mod, primaryKeyPtr) != 0
+	}
+	return
 }
 
 func (c *Conn) error(rc uint64, sql ...string) error {
 	return c.sqlite.error(rc, c.handle, sql...)
 }
 
-// DriverConn is implemented by the SQLite [database/sql] driver connection.
-//
-// It can be used to access advanced SQLite features like
-// [savepoints], [online backup] and [incremental BLOB I/O].
-//
-// [savepoints]: https://www.sqlite.org/lang_savepoint.html
-// [online backup]: https://www.sqlite.org/backup.html
-// [incremental BLOB I/O]: https://www.sqlite.org/c3ref/blob_open.html
-type DriverConn interface {
-	driver.Conn
-	driver.ConnBeginTx
-	driver.ExecerContext
-	driver.ConnPrepareContext
-
-	SetInterrupt(ctx context.Context) (old context.Context)
-
-	Savepoint() Savepoint
-	Backup(srcDB, dstURI string) error
-	Restore(dstDB, srcURI string) error
-	OpenBlob(db, table, column string, row int64, write bool) (*Blob, error)
+func (c *Conn) stmtsIter(yield func(*Stmt) bool) {
+	for _, s := range c.stmts {
+		if !yield(s) {
+			break
+		}
+	}
 }

conn_iter.go

@@ -0,0 +1,11 @@
+//go:build go1.23
+
+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

@@ -0,0 +1,9 @@
+//go:build !go1.23
+
+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

@@ -7,18 +7,18 @@ const (
 	_ROW  = 100 /* sqlite3_step() has another row ready */
 	_DONE = 101 /* sqlite3_step() has finished executing */
 
-	_UTF8 = 1
-
-	_MAX_STRING = 512 // Used for short strings: names, error messages…
-
-	_MAX_ALLOCATION_SIZE = 0x7ffffeff
+	_MAX_NAME         = 1e6 // Self-imposed limit for most NUL terminated strings.
+	_MAX_LENGTH       = 1e9
+	_MAX_SQL_LENGTH   = 1e9
+	_MAX_FUNCTION_ARG = 100
 
 	ptrlen = 4
+	intlen = 4
 )
 
 // ErrorCode is a result code that [Error.Code] might return.
 //
-// https://www.sqlite.org/rescode.html
+// https://sqlite.org/rescode.html
 type ErrorCode uint8
 
 const (
@@ -54,7 +54,7 @@ const (
 
 // ExtendedErrorCode is a result code that [Error.ExtendedCode] might return.
 //
-// https://www.sqlite.org/rescode.html
+// https://sqlite.org/rescode.html
 type (
 	ExtendedErrorCode uint16
 	xErrorCode        = ExtendedErrorCode
@@ -97,6 +97,7 @@ const (
 	IOERR_ROLLBACK_ATOMIC   ExtendedErrorCode = xErrorCode(IOERR) | (31 << 8)
 	IOERR_DATA              ExtendedErrorCode = xErrorCode(IOERR) | (32 << 8)
 	IOERR_CORRUPTFS         ExtendedErrorCode = xErrorCode(IOERR) | (33 << 8)
+	IOERR_IN_PAGE           ExtendedErrorCode = xErrorCode(IOERR) | (34 << 8)
 	LOCKED_SHAREDCACHE      ExtendedErrorCode = xErrorCode(LOCKED) | (1 << 8)
 	LOCKED_VTAB             ExtendedErrorCode = xErrorCode(LOCKED) | (2 << 8)
 	BUSY_RECOVERY           ExtendedErrorCode = xErrorCode(BUSY) | (1 << 8)
@@ -106,7 +107,7 @@ const (
 	CANTOPEN_ISDIR          ExtendedErrorCode = xErrorCode(CANTOPEN) | (2 << 8)
 	CANTOPEN_FULLPATH       ExtendedErrorCode = xErrorCode(CANTOPEN) | (3 << 8)
 	CANTOPEN_CONVPATH       ExtendedErrorCode = xErrorCode(CANTOPEN) | (4 << 8)
-	CANTOPEN_DIRTYWAL       ExtendedErrorCode = xErrorCode(CANTOPEN) | (5 << 8) /* Not Used */
+	// CANTOPEN_DIRTYWAL    ExtendedErrorCode = xErrorCode(CANTOPEN) | (5 << 8) /* Not Used */
 	CANTOPEN_SYMLINK        ExtendedErrorCode = xErrorCode(CANTOPEN) | (6 << 8)
 	CORRUPT_VTAB            ExtendedErrorCode = xErrorCode(CORRUPT) | (1 << 8)
 	CORRUPT_SEQUENCE        ExtendedErrorCode = xErrorCode(CORRUPT) | (2 << 8)
@@ -139,7 +140,7 @@ const (
 
 // OpenFlag is a flag for the [OpenFlags] function.
 //
-// https://www.sqlite.org/c3ref/c_open_autoproxy.html
+// https://sqlite.org/c3ref/c_open_autoproxy.html
 type OpenFlag uint32
 
 const (
@@ -158,30 +159,231 @@ const (
 
 // PrepareFlag is a flag that can be passed to [Conn.PrepareFlags].
 //
-// https://www.sqlite.org/c3ref/c_prepare_normalize.html
+// https://sqlite.org/c3ref/c_prepare_normalize.html
 type PrepareFlag uint32
 
 const (
 	PREPARE_PERSISTENT PrepareFlag = 0x01
 	PREPARE_NORMALIZE  PrepareFlag = 0x02
 	PREPARE_NO_VTAB    PrepareFlag = 0x04
+	PREPARE_DONT_LOG   PrepareFlag = 0x10
 )
 
-// FunctionFlag is a flag that can be passed to [Conn.PrepareFlags].
+// FunctionFlag is a flag that can be passed to
+// [Conn.CreateFunction] and [Conn.CreateWindowFunction].
 //
-// https://www.sqlite.org/c3ref/c_deterministic.html
+// https://sqlite.org/c3ref/c_deterministic.html
 type FunctionFlag uint32
 
 const (
 	DETERMINISTIC FunctionFlag = 0x000000800
 	DIRECTONLY    FunctionFlag = 0x000080000
-	SUBTYPE       FunctionFlag = 0x000100000
 	INNOCUOUS     FunctionFlag = 0x000200000
+	SELFORDER1    FunctionFlag = 0x002000000
+	// SUBTYPE        FunctionFlag = 0x000100000
+	// RESULT_SUBTYPE FunctionFlag = 0x001000000
+)
+
+// StmtStatus name counter values associated with the [Stmt.Status] method.
+//
+// https://sqlite.org/c3ref/c_stmtstatus_counter.html
+type StmtStatus uint32
+
+const (
+	STMTSTATUS_FULLSCAN_STEP StmtStatus = 1
+	STMTSTATUS_SORT          StmtStatus = 2
+	STMTSTATUS_AUTOINDEX     StmtStatus = 3
+	STMTSTATUS_VM_STEP       StmtStatus = 4
+	STMTSTATUS_REPREPARE     StmtStatus = 5
+	STMTSTATUS_RUN           StmtStatus = 6
+	STMTSTATUS_FILTER_MISS   StmtStatus = 7
+	STMTSTATUS_FILTER_HIT    StmtStatus = 8
+	STMTSTATUS_MEMUSED       StmtStatus = 99
+)
+
+// DBStatus are the available "verbs" that can be passed to the [Conn.Status] method.
+//
+// https://sqlite.org/c3ref/c_dbstatus_options.html
+type DBStatus uint32
+
+const (
+	DBSTATUS_LOOKASIDE_USED      DBStatus = 0
+	DBSTATUS_CACHE_USED          DBStatus = 1
+	DBSTATUS_SCHEMA_USED         DBStatus = 2
+	DBSTATUS_STMT_USED           DBStatus = 3
+	DBSTATUS_LOOKASIDE_HIT       DBStatus = 4
+	DBSTATUS_LOOKASIDE_MISS_SIZE DBStatus = 5
+	DBSTATUS_LOOKASIDE_MISS_FULL DBStatus = 6
+	DBSTATUS_CACHE_HIT           DBStatus = 7
+	DBSTATUS_CACHE_MISS          DBStatus = 8
+	DBSTATUS_CACHE_WRITE         DBStatus = 9
+	DBSTATUS_DEFERRED_FKS        DBStatus = 10
+	DBSTATUS_CACHE_USED_SHARED   DBStatus = 11
+	DBSTATUS_CACHE_SPILL         DBStatus = 12
+	// DBSTATUS_MAX              DBStatus = 12
+)
+
+// DBConfig are the available database connection configuration options.
+//
+// https://sqlite.org/c3ref/c_dbconfig_defensive.html
+type DBConfig uint32
+
+const (
+	// DBCONFIG_MAINDBNAME         DBConfig = 1000
+	// DBCONFIG_LOOKASIDE          DBConfig = 1001
+	DBCONFIG_ENABLE_FKEY           DBConfig = 1002
+	DBCONFIG_ENABLE_TRIGGER        DBConfig = 1003
+	DBCONFIG_ENABLE_FTS3_TOKENIZER DBConfig = 1004
+	DBCONFIG_ENABLE_LOAD_EXTENSION DBConfig = 1005
+	DBCONFIG_NO_CKPT_ON_CLOSE      DBConfig = 1006
+	DBCONFIG_ENABLE_QPSG           DBConfig = 1007
+	DBCONFIG_TRIGGER_EQP           DBConfig = 1008
+	DBCONFIG_RESET_DATABASE        DBConfig = 1009
+	DBCONFIG_DEFENSIVE             DBConfig = 1010
+	DBCONFIG_WRITABLE_SCHEMA       DBConfig = 1011
+	DBCONFIG_LEGACY_ALTER_TABLE    DBConfig = 1012
+	DBCONFIG_DQS_DML               DBConfig = 1013
+	DBCONFIG_DQS_DDL               DBConfig = 1014
+	DBCONFIG_ENABLE_VIEW           DBConfig = 1015
+	DBCONFIG_LEGACY_FILE_FORMAT    DBConfig = 1016
+	DBCONFIG_TRUSTED_SCHEMA        DBConfig = 1017
+	DBCONFIG_STMT_SCANSTATUS       DBConfig = 1018
+	DBCONFIG_REVERSE_SCANORDER     DBConfig = 1019
+	// DBCONFIG_MAX                DBConfig = 1019
+)
+
+// FcntlOpcode are the available opcodes for [Conn.FileControl].
+//
+// https://sqlite.org/c3ref/c_fcntl_begin_atomic_write.html
+type FcntlOpcode uint32
+
+const (
+	FCNTL_LOCKSTATE           FcntlOpcode = 1
+	FCNTL_CHUNK_SIZE          FcntlOpcode = 6
+	FCNTL_FILE_POINTER        FcntlOpcode = 7
+	FCNTL_PERSIST_WAL         FcntlOpcode = 10
+	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
+)
+
+// LimitCategory are the available run-time limit categories.
+//
+// https://sqlite.org/c3ref/c_limit_attached.html
+type LimitCategory uint32
+
+const (
+	LIMIT_LENGTH              LimitCategory = 0
+	LIMIT_SQL_LENGTH          LimitCategory = 1
+	LIMIT_COLUMN              LimitCategory = 2
+	LIMIT_EXPR_DEPTH          LimitCategory = 3
+	LIMIT_COMPOUND_SELECT     LimitCategory = 4
+	LIMIT_VDBE_OP             LimitCategory = 5
+	LIMIT_FUNCTION_ARG        LimitCategory = 6
+	LIMIT_ATTACHED            LimitCategory = 7
+	LIMIT_LIKE_PATTERN_LENGTH LimitCategory = 8
+	LIMIT_VARIABLE_NUMBER     LimitCategory = 9
+	LIMIT_TRIGGER_DEPTH       LimitCategory = 10
+	LIMIT_WORKER_THREADS      LimitCategory = 11
+)
+
+// AuthorizerActionCode are the integer action codes
+// that the authorizer callback may be passed.
+//
+// https://sqlite.org/c3ref/c_alter_table.html
+type AuthorizerActionCode uint32
+
+const (
+	/***************************************************** 3rd ************ 4th ***********/
+	AUTH_CREATE_INDEX        AuthorizerActionCode = 1  /* Index Name      Table Name      */
+	AUTH_CREATE_TABLE        AuthorizerActionCode = 2  /* Table Name      NULL            */
+	AUTH_CREATE_TEMP_INDEX   AuthorizerActionCode = 3  /* Index Name      Table Name      */
+	AUTH_CREATE_TEMP_TABLE   AuthorizerActionCode = 4  /* Table Name      NULL            */
+	AUTH_CREATE_TEMP_TRIGGER AuthorizerActionCode = 5  /* Trigger Name    Table Name      */
+	AUTH_CREATE_TEMP_VIEW    AuthorizerActionCode = 6  /* View Name       NULL            */
+	AUTH_CREATE_TRIGGER      AuthorizerActionCode = 7  /* Trigger Name    Table Name      */
+	AUTH_CREATE_VIEW         AuthorizerActionCode = 8  /* View Name       NULL            */
+	AUTH_DELETE              AuthorizerActionCode = 9  /* Table Name      NULL            */
+	AUTH_DROP_INDEX          AuthorizerActionCode = 10 /* Index Name      Table Name      */
+	AUTH_DROP_TABLE          AuthorizerActionCode = 11 /* Table Name      NULL            */
+	AUTH_DROP_TEMP_INDEX     AuthorizerActionCode = 12 /* Index Name      Table Name      */
+	AUTH_DROP_TEMP_TABLE     AuthorizerActionCode = 13 /* Table Name      NULL            */
+	AUTH_DROP_TEMP_TRIGGER   AuthorizerActionCode = 14 /* Trigger Name    Table Name      */
+	AUTH_DROP_TEMP_VIEW      AuthorizerActionCode = 15 /* View Name       NULL            */
+	AUTH_DROP_TRIGGER        AuthorizerActionCode = 16 /* Trigger Name    Table Name      */
+	AUTH_DROP_VIEW           AuthorizerActionCode = 17 /* View Name       NULL            */
+	AUTH_INSERT              AuthorizerActionCode = 18 /* Table Name      NULL            */
+	AUTH_PRAGMA              AuthorizerActionCode = 19 /* Pragma Name     1st arg or NULL */
+	AUTH_READ                AuthorizerActionCode = 20 /* Table Name      Column Name     */
+	AUTH_SELECT              AuthorizerActionCode = 21 /* NULL            NULL            */
+	AUTH_TRANSACTION         AuthorizerActionCode = 22 /* Operation       NULL            */
+	AUTH_UPDATE              AuthorizerActionCode = 23 /* Table Name      Column Name     */
+	AUTH_ATTACH              AuthorizerActionCode = 24 /* Filename        NULL            */
+	AUTH_DETACH              AuthorizerActionCode = 25 /* Database Name   NULL            */
+	AUTH_ALTER_TABLE         AuthorizerActionCode = 26 /* Database Name   Table Name      */
+	AUTH_REINDEX             AuthorizerActionCode = 27 /* Index Name      NULL            */
+	AUTH_ANALYZE             AuthorizerActionCode = 28 /* Table Name      NULL            */
+	AUTH_CREATE_VTABLE       AuthorizerActionCode = 29 /* Table Name      Module Name     */
+	AUTH_DROP_VTABLE         AuthorizerActionCode = 30 /* Table Name      Module Name     */
+	AUTH_FUNCTION            AuthorizerActionCode = 31 /* NULL            Function Name   */
+	AUTH_SAVEPOINT           AuthorizerActionCode = 32 /* Operation       Savepoint Name  */
+	AUTH_RECURSIVE           AuthorizerActionCode = 33 /* NULL            NULL            */
+	// AUTH_COPY             AuthorizerActionCode = 0  /* No longer used */
+)
+
+// AuthorizerReturnCode are the integer codes
+// that the authorizer callback may return.
+//
+// https://sqlite.org/c3ref/c_deny.html
+type AuthorizerReturnCode uint32
+
+const (
+	AUTH_OK     AuthorizerReturnCode = 0
+	AUTH_DENY   AuthorizerReturnCode = 1 /* Abort the SQL statement with an error */
+	AUTH_IGNORE AuthorizerReturnCode = 2 /* Don't allow access, but don't generate an error */
+)
+
+// CheckpointMode are all the checkpoint mode values.
+//
+// https://sqlite.org/c3ref/c_checkpoint_full.html
+type CheckpointMode uint32
+
+const (
+	CHECKPOINT_PASSIVE  CheckpointMode = 0 /* Do as much as possible w/o blocking */
+	CHECKPOINT_FULL     CheckpointMode = 1 /* Wait for writers, then checkpoint */
+	CHECKPOINT_RESTART  CheckpointMode = 2 /* Like FULL but wait for readers */
+	CHECKPOINT_TRUNCATE CheckpointMode = 3 /* Like RESTART but also truncate WAL */
+)
+
+// TxnState are the allowed return values from [Conn.TxnState].
+//
+// https://sqlite.org/c3ref/c_txn_none.html
+type TxnState uint32
+
+const (
+	TXN_NONE  TxnState = 0
+	TXN_READ  TxnState = 1
+	TXN_WRITE TxnState = 2
+)
+
+// TraceEvent identify classes of events that can be monitored with [Conn.Trace].
+//
+// https://sqlite.org/c3ref/c_trace.html
+type TraceEvent uint32
+
+const (
+	TRACE_STMT    TraceEvent = 0x01
+	TRACE_PROFILE TraceEvent = 0x02
+	TRACE_ROW     TraceEvent = 0x04
+	TRACE_CLOSE   TraceEvent = 0x08
 )
 
 // Datatype is a fundamental datatype of SQLite.
 //
-// https://www.sqlite.org/c3ref/c_blob.html
+// https://sqlite.org/c3ref/c_blob.html
 type Datatype uint32
 
 const (

context.go

@@ -1,6 +1,7 @@
 package sqlite3
 
 import (
+	"encoding/json"
 	"errors"
 	"math"
 	"time"
@@ -11,164 +12,217 @@ import (
 // Context is the context in which an SQL function executes.
 // An SQLite [Context] is in no way related to a Go [context.Context].
 //
-// https://www.sqlite.org/c3ref/context.html
+// https://sqlite.org/c3ref/context.html
 type Context struct {
-	*sqlite
+	c      *Conn
 	handle uint32
 }
 
+// Conn returns the database connection of the
+// [Conn.CreateFunction] or [Conn.CreateWindowFunction]
+// routines that originally registered the application defined function.
+//
+// https://sqlite.org/c3ref/context_db_handle.html
+func (ctx Context) Conn() *Conn {
+	return ctx.c
+}
+
 // SetAuxData saves metadata for argument n of the function.
 //
-// https://www.sqlite.org/c3ref/get_auxdata.html
-func (c Context) SetAuxData(n int, data any) {
-	ptr := util.AddHandle(c.ctx, data)
-	c.call(c.api.setAuxData, uint64(c.handle), uint64(n), uint64(ptr))
+// 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))
 }
 
 // GetAuxData returns metadata for argument n of the function.
 //
-// https://www.sqlite.org/c3ref/get_auxdata.html
-func (c Context) GetAuxData(n int) any {
-	ptr := uint32(c.call(c.api.getAuxData, uint64(c.handle), uint64(n)))
-	return util.GetHandle(c.ctx, ptr)
+// 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)
 }
 
 // ResultBool sets the result of the function to a bool.
 // SQLite does not have a separate boolean storage class.
 // Instead, boolean values are stored as integers 0 (false) and 1 (true).
 //
-// https://www.sqlite.org/c3ref/result_blob.html
-func (c Context) ResultBool(value bool) {
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultBool(value bool) {
 	var i int64
 	if value {
 		i = 1
 	}
-	c.ResultInt64(i)
+	ctx.ResultInt64(i)
 }
 
 // ResultInt sets the result of the function to an int.
 //
-// https://www.sqlite.org/c3ref/result_blob.html
-func (c Context) ResultInt(value int) {
-	c.ResultInt64(int64(value))
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultInt(value int) {
+	ctx.ResultInt64(int64(value))
 }
 
 // ResultInt64 sets the result of the function to an int64.
 //
-// https://www.sqlite.org/c3ref/result_blob.html
-func (c Context) ResultInt64(value int64) {
-	c.call(c.api.resultInteger,
-		uint64(c.handle), uint64(value))
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultInt64(value int64) {
+	ctx.c.call("sqlite3_result_int64",
+		uint64(ctx.handle), uint64(value))
 }
 
 // ResultFloat sets the result of the function to a float64.
 //
-// https://www.sqlite.org/c3ref/result_blob.html
-func (c Context) ResultFloat(value float64) {
-	c.call(c.api.resultFloat,
-		uint64(c.handle), math.Float64bits(value))
+// 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))
 }
 
 // ResultText sets the result of the function to a string.
 //
-// https://www.sqlite.org/c3ref/result_blob.html
-func (c Context) ResultText(value string) {
-	ptr := c.newString(value)
-	c.call(c.api.resultText,
-		uint64(c.handle), uint64(ptr), uint64(len(value)),
-		uint64(c.api.destructor), _UTF8)
+// 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)))
+}
+
+// ResultRawText sets the text 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) ResultRawText(value []byte) {
+	ptr := ctx.c.newBytes(value)
+	ctx.c.call("sqlite3_result_text_go",
+		uint64(ctx.handle), uint64(ptr), uint64(len(value)))
 }
 
 // ResultBlob sets the result of the function to a []byte.
 // Returning a nil slice is the same as calling [Context.ResultNull].
 //
-// https://www.sqlite.org/c3ref/result_blob.html
-func (c Context) ResultBlob(value []byte) {
-	ptr := c.newBytes(value)
-	c.call(c.api.resultBlob,
-		uint64(c.handle), uint64(ptr), uint64(len(value)),
-		uint64(c.api.destructor))
+// 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)))
 }
 
-// BindZeroBlob sets the result of the function to a zero-filled, length n BLOB.
+// ResultZeroBlob sets the result of the function to a zero-filled, length n BLOB.
 //
-// https://www.sqlite.org/c3ref/result_blob.html
-func (c Context) ResultZeroBlob(n int64) {
-	c.call(c.api.resultZeroBlob,
-		uint64(c.handle), uint64(n))
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultZeroBlob(n int64) {
+	ctx.c.call("sqlite3_result_zeroblob64",
+		uint64(ctx.handle), uint64(n))
 }
 
 // ResultNull sets the result of the function to NULL.
 //
-// https://www.sqlite.org/c3ref/result_blob.html
-func (c Context) ResultNull() {
-	c.call(c.api.resultNull,
-		uint64(c.handle))
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultNull() {
+	ctx.c.call("sqlite3_result_null",
+		uint64(ctx.handle))
 }
 
 // ResultTime sets the result of the function to a [time.Time].
 //
-// https://www.sqlite.org/c3ref/result_blob.html
-func (c Context) ResultTime(value time.Time, format TimeFormat) {
-	if format == TimeFormatDefault {
-		c.resultRFC3339Nano(value)
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultTime(value time.Time, format TimeFormat) {
+	switch format {
+	case TimeFormatDefault, TimeFormatAuto, time.RFC3339Nano:
+		ctx.resultRFC3339Nano(value)
 		return
 	}
 	switch v := format.Encode(value).(type) {
 	case string:
-		c.ResultText(v)
+		ctx.ResultText(v)
 	case int64:
-		c.ResultInt64(v)
+		ctx.ResultInt64(v)
 	case float64:
-		c.ResultFloat(v)
+		ctx.ResultFloat(v)
 	default:
 		panic(util.AssertErr())
 	}
 }
 
-func (c Context) resultRFC3339Nano(value time.Time) {
-	const maxlen = uint64(len(time.RFC3339Nano))
+func (ctx Context) resultRFC3339Nano(value time.Time) {
+	const maxlen = uint64(len(time.RFC3339Nano)) + 5
 
-	ptr := c.new(maxlen)
-	buf := util.View(c.mod, ptr, maxlen)
+	ptr := ctx.c.new(maxlen)
+	buf := util.View(ctx.c.mod, ptr, maxlen)
 	buf = value.AppendFormat(buf[:0], time.RFC3339Nano)
 
-	c.call(c.api.resultText,
-		uint64(c.handle), uint64(ptr), uint64(len(buf)),
-		uint64(c.api.destructor), _UTF8)
+	ctx.c.call("sqlite3_result_text_go",
+		uint64(ctx.handle), uint64(ptr), uint64(len(buf)))
+}
+
+// ResultPointer sets the result of the function to NULL, just like [Context.ResultNull],
+// except that it also associates ptr with that NULL value such that it can be retrieved
+// within an application-defined SQL function using [Value.Pointer].
+//
+// 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)
+}
+
+// ResultValue sets the result of the function to a copy of [Value].
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultValue(value Value) {
+	if value.c != ctx.c {
+		ctx.ResultError(MISUSE)
+		return
+	}
+	ctx.c.call("sqlite3_result_value",
+		uint64(ctx.handle), uint64(value.handle))
 }
 
 // ResultError sets the result of the function an error.
 //
-// https://www.sqlite.org/c3ref/result_blob.html
-func (c Context) ResultError(err error) {
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultError(err error) {
 	if errors.Is(err, NOMEM) {
-		c.call(c.api.resultErrorMem, uint64(c.handle))
+		ctx.c.call("sqlite3_result_error_nomem", uint64(ctx.handle))
 		return
 	}
 
 	if errors.Is(err, TOOBIG) {
-		c.call(c.api.resultErrorBig, uint64(c.handle))
+		ctx.c.call("sqlite3_result_error_toobig", uint64(ctx.handle))
 		return
 	}
 
-	str := err.Error()
-	ptr := c.newString(str)
-	c.call(c.api.resultError,
-		uint64(c.handle), uint64(ptr), uint64(len(str)))
-	c.free(ptr)
-
-	var code uint64
-	var ecode ErrorCode
-	var xcode xErrorCode
-	switch {
-	case errors.As(err, &xcode):
-		code = uint64(xcode)
-	case errors.As(err, &ecode):
-		code = uint64(ecode)
+	msg, code := errorCode(err, _OK)
+	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)))
 	}
-	if code != 0 {
-		c.call(c.api.resultErrorCode,
-			uint64(c.handle), code)
+	if code != _OK {
+		ctx.c.call("sqlite3_result_error_code",
+			uint64(ctx.handle), uint64(code))
 	}
 }
+
+// VTabNoChange may return true if a column is being fetched as part
+// of an update during which the column value will not change.
+//
+// https://sqlite.org/c3ref/vtab_nochange.html
+func (ctx Context) VTabNoChange() bool {
+	r := ctx.c.call("sqlite3_vtab_nochange", uint64(ctx.handle))
+	return r != 0
+}

driver/driver.go

@@ -8,10 +8,51 @@
 //
 // The data source name for "sqlite3" databases can be a filename or a "file:" [URI].
 //
+// # Default transaction mode
+//
 // The [TRANSACTION] mode can be specified using "_txlock":
 //
 //	sql.Open("sqlite3", "file:demo.db?_txlock=immediate")
 //
+// Possible values are: "deferred" (the default), "immediate", "exclusive".
+// Regardless of "_txlock":
+//   - a [linearizable] transaction is always "exclusive";
+//   - a [serializable] transaction is always "immediate";
+//   - a [read-only] transaction is always "deferred".
+//
+// # Working with time
+//
+// The time encoding/decoding format can be specified using "_timefmt":
+//
+//	sql.Open("sqlite3", "file:demo.db?_timefmt=sqlite")
+//
+// Possible values are: "auto" (the default), "sqlite", "rfc3339";
+//   - "auto" encodes as RFC 3339 and decodes any [format] supported by SQLite;
+//   - "sqlite" encodes as SQLite and decodes any [format] supported by SQLite;
+//   - "rfc3339" encodes and decodes RFC 3339 only.
+//
+// If you encode as RFC 3339 (the default),
+// consider using the TIME [collating sequence] to produce a time-ordered sequence.
+//
+// To scan values in other formats, [sqlite3.TimeFormat.Scanner] may be helpful.
+// To bind values in other 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 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, or nil,
+// depending on the column type and what whoever wrote the value.
+// [sqlite3.TimeFormat.Decode] may help.
+//
+// # Setting PRAGMAs
+//
 // [PRAGMA] statements can be specified using "_pragma":
 //
 //	sql.Open("sqlite3", "file:demo.db?_pragma=busy_timeout(10000)")
@@ -19,136 +60,283 @@
 // If no PRAGMAs are specified, a busy timeout of 1 minute is set.
 //
 // Order matters:
-// busy timeout and locking mode should be the first PRAGMAs set, in that order.
+// encryption keys, busy timeout and locking mode should be the first PRAGMAs set,
+// in that order.
 //
-// [URI]: https://www.sqlite.org/uri.html
-// [PRAGMA]: https://www.sqlite.org/pragma.html
-// [TRANSACTION]: https://www.sqlite.org/lang_transaction.html#deferred_immediate_and_exclusive_transactions
+// [URI]: https://sqlite.org/uri.html
+// [PRAGMA]: https://sqlite.org/pragma.html
+// [TRANSACTION]: https://sqlite.org/lang_transaction.html#deferred_immediate_and_exclusive_transactions
+// [linearizable]: https://pkg.go.dev/database/sql#TxOptions
+// [serializable]: https://pkg.go.dev/database/sql#TxOptions
+// [read-only]: https://pkg.go.dev/database/sql#TxOptions
+// [format]: https://sqlite.org/lang_datefunc.html#time_values
+// [collating sequence]: https://sqlite.org/datatype3.html#collating_sequences
 package driver
 
 import (
 	"context"
 	"database/sql"
 	"database/sql/driver"
+	"errors"
 	"fmt"
 	"io"
 	"net/url"
+	"reflect"
 	"strings"
 	"time"
+	"unsafe"
 
 	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/internal/util"
 )
 
+// This variable can be replaced with -ldflags:
+//
+//	go build -ldflags="-X github.com/ncruces/go-sqlite3/driver.driverName=sqlite"
+var driverName = "sqlite3"
+
 func init() {
-	sql.Register("sqlite3", sqlite{})
+	if driverName != "" {
+		sql.Register(driverName, &SQLite{})
+	}
 }
 
-type sqlite struct{}
-
-func (sqlite) Open(name string) (_ driver.Conn, err error) {
-	var c conn
-	c.Conn, err = sqlite3.Open(name)
+// Open opens the SQLite database specified by dataSourceName as a [database/sql.DB].
+//
+// Open accepts zero, one, or two callbacks (nil callbacks are ignored).
+// The first callback is called when the driver opens a new connection.
+// 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) {
+	if len(fn) > 2 {
+		return nil, sqlite3.MISUSE
+	}
+	var init, term func(*sqlite3.Conn) error
+	if len(fn) > 1 {
+		term = fn[1]
+	}
+	if len(fn) > 0 {
+		init = fn[0]
+	}
+	c, err := newConnector(dataSourceName, init, term)
 	if err != nil {
 		return nil, err
 	}
+	return sql.OpenDB(c), nil
+}
 
-	var pragmas bool
-	c.txBegin = "BEGIN"
+// SQLite implements [database/sql/driver.Driver].
+type SQLite struct{}
+
+var (
+	// Ensure these interfaces are implemented:
+	_ driver.DriverContext = &SQLite{}
+)
+
+// Open implements [database/sql/driver.Driver].
+func (d *SQLite) Open(name string) (driver.Conn, error) {
+	c, err := newConnector(name, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return c.Connect(context.Background())
+}
+
+// OpenConnector implements [database/sql/driver.DriverContext].
+func (d *SQLite) OpenConnector(name string) (driver.Connector, error) {
+	return newConnector(name, nil, nil)
+}
+
+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, _ := url.ParseQuery(after)
-
-			switch s := query.Get("_txlock"); s {
-			case "":
-				c.txBegin = "BEGIN"
-			case "deferred", "immediate", "exclusive":
-				c.txBegin = "BEGIN " + s
-			default:
-				c.Close()
-				return nil, fmt.Errorf("sqlite3: invalid _txlock: %s", s)
+			query, err := url.ParseQuery(after)
+			if err != nil {
+				return nil, err
 			}
-
-			pragmas = len(query["_pragma"]) > 0
+			txlock = query.Get("_txlock")
+			timefmt = query.Get("_timefmt")
+			c.pragmas = query.Has("_pragma")
 		}
 	}
-	if !pragmas {
-		err := c.Conn.Exec(`PRAGMA busy_timeout=60000`)
-		if err != nil {
-			c.Close()
-			return nil, err
-		}
-		c.reusable = true
-	} else {
-		s, _, err := c.Conn.Prepare(`
-			SELECT * FROM
-				PRAGMA_locking_mode,
-				PRAGMA_query_only;
-		`)
-		if err != nil {
-			c.Close()
-			return nil, err
-		}
-		if s.Step() {
-			c.reusable = s.ColumnText(0) == "normal"
-			c.readOnly = s.ColumnRawText(1)[0] // 0 or 1
-		}
-		err = s.Close()
-		if err != nil {
-			c.Close()
-			return nil, err
-		}
+
+	switch txlock {
+	case "", "deferred", "concurrent", "immediate", "exclusive":
+		c.txLock = txlock
+	default:
+		return nil, fmt.Errorf("sqlite3: invalid _txlock: %s", txlock)
+	}
+
+	switch timefmt {
+	case "":
+		c.tmRead = sqlite3.TimeFormatAuto
+		c.tmWrite = sqlite3.TimeFormatDefault
+	case "sqlite":
+		c.tmRead = sqlite3.TimeFormatAuto
+		c.tmWrite = sqlite3.TimeFormat3
+	case "rfc3339":
+		c.tmRead = sqlite3.TimeFormatDefault
+		c.tmWrite = sqlite3.TimeFormatDefault
+	default:
+		c.tmRead = sqlite3.TimeFormat(timefmt)
+		c.tmWrite = sqlite3.TimeFormat(timefmt)
 	}
 	return &c, nil
 }
 
+type connector struct {
+	init    func(*sqlite3.Conn) error
+	term    func(*sqlite3.Conn) error
+	name    string
+	txLock  string
+	tmRead  sqlite3.TimeFormat
+	tmWrite sqlite3.TimeFormat
+	pragmas bool
+}
+
+func (n *connector) Driver() driver.Driver {
+	return &SQLite{}
+}
+
+func (n *connector) Connect(ctx context.Context) (res driver.Conn, err error) {
+	c := &conn{
+		txLock:  n.txLock,
+		tmRead:  n.tmRead,
+		tmWrite: n.tmWrite,
+	}
+
+	c.Conn, err = sqlite3.OpenContext(ctx, n.name)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		if res == nil {
+			c.Close()
+		}
+	}()
+
+	old := c.Conn.SetInterrupt(ctx)
+	defer c.Conn.SetInterrupt(old)
+
+	if !n.pragmas {
+		err = c.Conn.BusyTimeout(time.Minute)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if n.init != nil {
+		err = n.init(c.Conn)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if n.pragmas || n.init != nil {
+		s, _, err := c.Conn.Prepare(`PRAGMA query_only`)
+		if err != nil {
+			return nil, err
+		}
+		defer s.Close()
+		if s.Step() && s.ColumnBool(0) {
+			c.readOnly = '1'
+		} else {
+			c.readOnly = '0'
+		}
+		err = s.Close()
+		if err != nil {
+			return nil, err
+		}
+	}
+	if n.term != nil {
+		err = c.Conn.Trace(sqlite3.TRACE_CLOSE, func(sqlite3.TraceEvent, any, any) error {
+			return n.term(c.Conn)
+		})
+		if err != nil {
+			return nil, err
+		}
+	}
+	return c, nil
+}
+
+// Conn is implemented by the SQLite [database/sql] driver connections.
+//
+// It can be used to access SQLite features like [online backup]:
+//
+//	db, err := driver.Open("temp.db")
+//	if err != nil {
+//		log.Fatal(err)
+//	}
+//	defer db.Close()
+//
+//	conn, err := db.Conn(context.TODO())
+//	if err != nil {
+//		log.Fatal(err)
+//	}
+//	defer conn.Close()
+//
+//	err = conn.Raw(func(driverConn any) error {
+//		conn := driverConn.(driver.Conn)
+//		return conn.Raw().Backup("main", "backup.db")
+//	})
+//	if err != nil {
+//		log.Fatal(err)
+//	}
+//
+// [online backup]: https://sqlite.org/backup.html
+type Conn interface {
+	Raw() *sqlite3.Conn
+	driver.Conn
+	driver.ConnBeginTx
+	driver.ConnPrepareContext
+}
+
 type conn struct {
 	*sqlite3.Conn
-	txBegin    string
-	txCommit   string
-	txRollback string
-	reusable   bool
-	readOnly   byte
+	txLock   string
+	txReset  string
+	tmRead   sqlite3.TimeFormat
+	tmWrite  sqlite3.TimeFormat
+	readOnly byte
 }
 
 var (
 	// Ensure these interfaces are implemented:
+	_ Conn                 = &conn{}
 	_ driver.ExecerContext = &conn{}
-	_ driver.ConnBeginTx   = &conn{}
-	_ driver.Validator     = &conn{}
-	_ sqlite3.DriverConn   = &conn{}
 )
 
-func (c *conn) IsValid() bool {
-	return c.reusable
+func (c *conn) Raw() *sqlite3.Conn {
+	return c.Conn
 }
 
+// Deprecated: use BeginTx instead.
 func (c *conn) Begin() (driver.Tx, error) {
+	// notest
 	return c.BeginTx(context.Background(), driver.TxOptions{})
 }
 
 func (c *conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {
-	txBegin := c.txBegin
-	c.txCommit = `COMMIT`
-	c.txRollback = `ROLLBACK`
-
-	if opts.ReadOnly {
-		txBegin = `
-			BEGIN deferred;
-			PRAGMA query_only=on`
-		c.txCommit = `
-			ROLLBACK;
-			PRAGMA query_only=` + string(c.readOnly)
-		c.txRollback = c.txCommit
-	}
-
+	var txLock string
 	switch opts.Isolation {
 	default:
 		return nil, util.IsolationErr
-	case
-		driver.IsolationLevel(sql.LevelDefault),
-		driver.IsolationLevel(sql.LevelSerializable):
-		break
+	case driver.IsolationLevel(sql.LevelLinearizable):
+		txLock = "exclusive"
+	case driver.IsolationLevel(sql.LevelSerializable):
+		txLock = "immediate"
+	case driver.IsolationLevel(sql.LevelDefault):
+		if !opts.ReadOnly {
+			txLock = c.txLock
+		}
+	}
+
+	c.txReset = ``
+	txBegin := `BEGIN ` + txLock
+	if opts.ReadOnly {
+		txBegin += ` ; PRAGMA query_only=on`
+		c.txReset = `; PRAGMA query_only=` + string(c.readOnly)
 	}
 
 	old := c.Conn.SetInterrupt(ctx)
@@ -162,18 +350,25 @@ func (c *conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, e
 }
 
 func (c *conn) Commit() error {
-	err := c.Conn.Exec(c.txCommit)
-	if err != nil && !c.GetAutocommit() {
+	err := c.Conn.Exec(`COMMIT` + c.txReset)
+	if err != nil && !c.Conn.GetAutocommit() {
 		c.Rollback()
 	}
 	return err
 }
 
 func (c *conn) Rollback() error {
-	return c.Conn.Exec(c.txRollback)
+	err := c.Conn.Exec(`ROLLBACK` + c.txReset)
+	if errors.Is(err, sqlite3.INTERRUPT) {
+		old := c.Conn.SetInterrupt(context.Background())
+		defer c.Conn.SetInterrupt(old)
+		err = c.Conn.Exec(`ROLLBACK` + c.txReset)
+	}
+	return err
 }
 
 func (c *conn) Prepare(query string) (driver.Stmt, error) {
+	// notest
 	return c.PrepareContext(context.Background(), query)
 }
 
@@ -185,20 +380,11 @@ func (c *conn) PrepareContext(ctx context.Context, query string) (driver.Stmt, e
 	if err != nil {
 		return nil, err
 	}
-	if tail != "" {
-		// Check if the tail contains any SQL.
-		st, _, err := c.Conn.Prepare(tail)
-		if err != nil {
-			s.Close()
-			return nil, err
-		}
-		if st != nil {
-			s.Close()
-			st.Close()
-			return nil, util.TailErr
-		}
+	if notWhitespace(tail) {
+		s.Close()
+		return nil, util.TailErr
 	}
-	return &stmt{s, c.Conn}, nil
+	return &stmt{Stmt: s, tmRead: c.tmRead, tmWrite: c.tmWrite, inputs: -2}, nil
 }
 
 func (c *conn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {
@@ -207,6 +393,12 @@ func (c *conn) ExecContext(ctx context.Context, query string, args []driver.Name
 		return nil, driver.ErrSkip
 	}
 
+	if savept, ok := ctx.(*saveptCtx); ok {
+		// Called from driver.Savepoint.
+		savept.Savepoint = c.Conn.Savepoint()
+		return resultRowsAffected(0), nil
+	}
+
 	old := c.Conn.SetInterrupt(ctx)
 	defer c.Conn.SetInterrupt(old)
 
@@ -218,9 +410,17 @@ func (c *conn) ExecContext(ctx context.Context, query string, args []driver.Name
 	return newResult(c.Conn), nil
 }
 
+func (c *conn) CheckNamedValue(arg *driver.NamedValue) error {
+	// Fast path: short circuit argument verification.
+	// Arguments will be rejected by conn.ExecContext.
+	return nil
+}
+
 type stmt struct {
-	Stmt *sqlite3.Stmt
-	Conn *sqlite3.Conn
+	*sqlite3.Stmt
+	tmWrite sqlite3.TimeFormat
+	tmRead  sqlite3.TimeFormat
+	inputs  int
 }
 
 var (
@@ -230,59 +430,67 @@ var (
 	_ driver.NamedValueChecker = &stmt{}
 )
 
-func (s *stmt) Close() error {
-	return s.Stmt.Close()
-}
-
 func (s *stmt) NumInput() int {
+	if s.inputs >= -1 {
+		return s.inputs
+	}
 	n := s.Stmt.BindCount()
 	for i := 1; i <= n; i++ {
 		if s.Stmt.BindName(i) != "" {
+			s.inputs = -1
 			return -1
 		}
 	}
+	s.inputs = n
 	return n
 }
 
 // Deprecated: use ExecContext instead.
 func (s *stmt) Exec(args []driver.Value) (driver.Result, error) {
+	// notest
 	return s.ExecContext(context.Background(), namedValues(args))
 }
 
 // Deprecated: use QueryContext instead.
 func (s *stmt) Query(args []driver.Value) (driver.Rows, error) {
+	// notest
 	return s.QueryContext(context.Background(), namedValues(args))
 }
 
 func (s *stmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) {
-	// Use QueryContext to setup bindings.
-	// No need to close rows: that simply resets the statement, exec does the same.
-	_, err := s.QueryContext(ctx, args)
+	err := s.setupBindings(args)
 	if err != nil {
 		return nil, err
 	}
 
+	old := s.Stmt.Conn().SetInterrupt(ctx)
+	defer s.Stmt.Conn().SetInterrupt(old)
+
 	err = s.Stmt.Exec()
+	s.Stmt.ClearBindings()
 	if err != nil {
 		return nil, err
 	}
 
-	return newResult(s.Conn), nil
+	return newResult(s.Stmt.Conn()), nil
 }
 
 func (s *stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
-	err := s.Stmt.ClearBindings()
+	err := s.setupBindings(args)
 	if err != nil {
 		return nil, err
 	}
+	return &rows{ctx: ctx, stmt: s}, nil
+}
 
+func (s *stmt) setupBindings(args []driver.NamedValue) (err error) {
 	var ids [3]int
 	for _, arg := range args {
 		ids := ids[:0]
 		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)
 				}
@@ -306,25 +514,30 @@ func (s *stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driv
 			case sqlite3.ZeroBlob:
 				err = s.Stmt.BindZeroBlob(id, int64(a))
 			case time.Time:
-				err = s.Stmt.BindTime(id, a, sqlite3.TimeFormatDefault)
+				err = s.Stmt.BindTime(id, a, s.tmWrite)
+			case util.JSON:
+				err = s.Stmt.BindJSON(id, a.Value)
+			case util.PointerUnwrap:
+				err = s.Stmt.BindPointer(id, util.UnwrapPointer(a))
 			case nil:
 				err = s.Stmt.BindNull(id)
 			default:
 				panic(util.AssertErr())
 			}
-		}
-		if err != nil {
-			return nil, err
+			if err != nil {
+				return err
+			}
 		}
 	}
-
-	return &rows{ctx, s.Stmt, s.Conn}, nil
+	return nil
 }
 
 func (s *stmt) CheckNamedValue(arg *driver.NamedValue) error {
 	switch arg.Value.(type) {
 	case bool, int, int64, float64, string, []byte,
-		sqlite3.ZeroBlob, time.Time, nil:
+		time.Time, sqlite3.ZeroBlob,
+		util.JSON, util.PointerUnwrap,
+		nil:
 		return nil
 	default:
 		return driver.ErrSkip
@@ -363,27 +576,167 @@ func (r resultRowsAffected) RowsAffected() (int64, error) {
 }
 
 type rows struct {
-	ctx  context.Context
-	Stmt *sqlite3.Stmt
-	Conn *sqlite3.Conn
+	ctx context.Context
+	*stmt
+	names []string
+	types []string
+	nulls []bool
+	scans []scantype
 }
 
+type scantype byte
+
+const (
+	_ANY  scantype = iota
+	_INT  scantype = scantype(sqlite3.INTEGER)
+	_REAL scantype = scantype(sqlite3.FLOAT)
+	_TEXT scantype = scantype(sqlite3.TEXT)
+	_BLOB scantype = scantype(sqlite3.BLOB)
+	_NULL scantype = scantype(sqlite3.NULL)
+	_BOOL scantype = iota
+	_TIME
+)
+
+var (
+	// Ensure these interfaces are implemented:
+	_ driver.RowsColumnTypeDatabaseTypeName = &rows{}
+	_ driver.RowsColumnTypeNullable         = &rows{}
+)
+
 func (r *rows) Close() error {
+	r.Stmt.ClearBindings()
 	return r.Stmt.Reset()
 }
 
 func (r *rows) Columns() []string {
-	count := r.Stmt.ColumnCount()
-	columns := make([]string, count)
-	for i := range columns {
-		columns[i] = r.Stmt.ColumnName(i)
+	if r.names == nil {
+		count := r.Stmt.ColumnCount()
+		names := make([]string, count)
+		for i := range names {
+			names[i] = r.Stmt.ColumnName(i)
+		}
+		r.names = names
+	}
+	return r.names
+}
+
+func (r *rows) loadColumnMetadata() {
+	if r.nulls == nil {
+		count := r.Stmt.ColumnCount()
+		nulls := make([]bool, count)
+		types := make([]string, count)
+		scans := make([]scantype, count)
+		for i := range nulls {
+			if col := r.Stmt.ColumnOriginName(i); col != "" {
+				types[i], _, nulls[i], _, _, _ = r.Stmt.Conn().TableColumnMetadata(
+					r.Stmt.ColumnDatabaseName(i),
+					r.Stmt.ColumnTableName(i),
+					col)
+				types[i] = strings.ToUpper(types[i])
+				// 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 types[i] {
+				case "INT", "INTEGER":
+					scans[i] = _INT
+				case "REAL":
+					scans[i] = _REAL
+				case "TEXT":
+					scans[i] = _TEXT
+				case "BLOB":
+					scans[i] = _BLOB
+				case "BOOLEAN":
+					scans[i] = _BOOL
+				case "DATE", "TIME", "DATETIME", "TIMESTAMP":
+					scans[i] = _TIME
+				}
+			}
+		}
+		r.nulls = nulls
+		r.types = types
+		r.scans = scans
+	}
+}
+
+func (r *rows) declType(index int) string {
+	if r.types == nil {
+		count := r.Stmt.ColumnCount()
+		types := make([]string, count)
+		for i := range types {
+			types[i] = strings.ToUpper(r.Stmt.ColumnDeclType(i))
+		}
+		r.types = types
+	}
+	return r.types[index]
+}
+
+func (r *rows) ColumnTypeDatabaseTypeName(index int) string {
+	r.loadColumnMetadata()
+	decltype := r.types[index]
+	if len := len(decltype); len > 0 && decltype[len-1] == ')' {
+		if i := strings.LastIndexByte(decltype, '('); i >= 0 {
+			decltype = decltype[:i]
+		}
+	}
+	return strings.TrimSpace(decltype)
+}
+
+func (r *rows) ColumnTypeNullable(index int) (nullable, ok bool) {
+	r.loadColumnMetadata()
+	if r.nulls[index] {
+		return false, true
+	}
+	return true, false
+}
+
+func (r *rows) ColumnTypeScanType(index int) (typ reflect.Type) {
+	r.loadColumnMetadata()
+	scan := r.scans[index]
+
+	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 == time.Time{}
+		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.TypeOf(int64(0))
+	case _REAL:
+		return reflect.TypeOf(float64(0))
+	case _TEXT:
+		return reflect.TypeOf("")
+	case _BLOB:
+		return reflect.TypeOf([]byte{})
+	case _BOOL:
+		return reflect.TypeOf(false)
+	case _TIME:
+		return reflect.TypeOf(time.Time{})
+	default:
+		return reflect.TypeOf((*any)(nil)).Elem()
 	}
-	return columns
 }
 
 func (r *rows) Next(dest []driver.Value) error {
-	old := r.Conn.SetInterrupt(r.ctx)
-	defer r.Conn.SetInterrupt(old)
+	old := r.Stmt.Conn().SetInterrupt(r.ctx)
+	defer r.Stmt.Conn().SetInterrupt(old)
 
 	if !r.Stmt.Step() {
 		if err := r.Stmt.Err(); err != nil {
@@ -392,26 +745,37 @@ func (r *rows) Next(dest []driver.Value) error {
 		return io.EOF
 	}
 
+	data := unsafe.Slice((*any)(unsafe.SliceData(dest)), len(dest))
+	err := r.Stmt.Columns(data...)
 	for i := range dest {
-		switch r.Stmt.ColumnType(i) {
-		case sqlite3.INTEGER:
-			dest[i] = r.Stmt.ColumnInt64(i)
-		case sqlite3.FLOAT:
-			dest[i] = r.Stmt.ColumnFloat(i)
-		case sqlite3.BLOB:
-			dest[i] = r.Stmt.ColumnRawBlob(i)
-		case sqlite3.TEXT:
-			dest[i] = stringOrTime(r.Stmt.ColumnRawText(i))
-		case sqlite3.NULL:
-			if buf, ok := dest[i].([]byte); ok {
-				dest[i] = buf[0:0]
-			} else {
-				dest[i] = nil
-			}
-		default:
-			panic(util.AssertErr())
+		if t, ok := r.decodeTime(i, dest[i]); ok {
+			dest[i] = t
 		}
 	}
-
-	return r.Stmt.Err()
+	return err
+}
+
+func (r *rows) decodeTime(i int, v any) (_ time.Time, ok bool) {
+	switch v := v.(type) {
+	case int64, float64:
+		// could be a time value
+	case string:
+		if r.tmWrite != "" && r.tmWrite != time.RFC3339 && r.tmWrite != time.RFC3339Nano {
+			break
+		}
+		t, ok := maybeTime(v)
+		if ok {
+			return t, true
+		}
+	default:
+		return
+	}
+	switch r.declType(i) {
+	case "DATE", "TIME", "DATETIME", "TIMESTAMP":
+		// could be a time value
+	default:
+		return
+	}
+	t, err := r.tmRead.Decode(v)
+	return t, err == nil
 }

driver/driver_test.go

@@ -6,14 +6,30 @@ import (
 	"database/sql"
 	"errors"
 	"math"
-	"path/filepath"
+	"net/url"
+	"reflect"
 	"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"
 )
 
+func Test_Open_error(t *testing.T) {
+	t.Parallel()
+
+	_, err := Open("", nil, nil, nil)
+	if err == nil {
+		t.Error("want error")
+	}
+	if !errors.Is(err, sqlite3.MISUSE) {
+		t.Errorf("got %v, want sqlite3.MISUSE", err)
+	}
+}
+
 func Test_Open_dir(t *testing.T) {
 	t.Parallel()
 
@@ -34,8 +50,11 @@ func Test_Open_dir(t *testing.T) {
 
 func Test_Open_pragma(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t, url.Values{
+		"_pragma": {"busy_timeout(1000)"},
+	})
 
-	db, err := sql.Open("sqlite3", "file::memory:?_pragma=busy_timeout(1000)")
+	db, err := sql.Open("sqlite3", tmp)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -53,8 +72,11 @@ func Test_Open_pragma(t *testing.T) {
 
 func Test_Open_pragma_invalid(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t, url.Values{
+		"_pragma": {"busy_timeout 1000"},
+	})
 
-	db, err := sql.Open("sqlite3", "file::memory:?_pragma=busy_timeout+1000")
+	db, err := sql.Open("sqlite3", tmp)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -78,10 +100,12 @@ func Test_Open_pragma_invalid(t *testing.T) {
 
 func Test_Open_txLock(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t, url.Values{
+		"_txlock": {"exclusive"},
+		"_pragma": {"busy_timeout(1000)"},
+	})
 
-	db, err := sql.Open("sqlite3", "file:"+
-		filepath.ToSlash(filepath.Join(t.TempDir(), "test.db"))+
-		"?_txlock=exclusive&_pragma=busy_timeout(0)")
+	db, err := sql.Open("sqlite3", tmp)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -112,14 +136,11 @@ func Test_Open_txLock(t *testing.T) {
 
 func Test_Open_txLock_invalid(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t, url.Values{
+		"_txlock": {"xclusive"},
+	})
 
-	db, err := sql.Open("sqlite3", "file::memory:?_txlock=xclusive")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db.Close()
-
-	_, err = db.Conn(context.TODO())
+	_, err := sql.Open("sqlite3", tmp+"_txlock=xclusive")
 	if err == nil {
 		t.Fatal("want error")
 	}
@@ -130,13 +151,15 @@ func Test_Open_txLock_invalid(t *testing.T) {
 
 func Test_BeginTx(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t, url.Values{
+		"_txlock": {"exclusive"},
+		"_pragma": {"busy_timeout(0)"},
+	})
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	db, err := sql.Open("sqlite3", "file:"+
-		filepath.ToSlash(filepath.Join(t.TempDir(), "test.db"))+
-		"?_txlock=exclusive&_pragma=busy_timeout(0)")
+	db, err := sql.Open("sqlite3", tmp)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -157,7 +180,7 @@ func Test_BeginTx(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	_, err = tx1.Exec(`CREATE TABLE IF NOT EXISTS test (col)`)
+	_, err = tx1.Exec(`CREATE TABLE test (col)`)
 	if err == nil {
 		t.Error("want error")
 	}
@@ -178,19 +201,14 @@ func Test_BeginTx(t *testing.T) {
 
 func Test_Prepare(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db, err := sql.Open("sqlite3", ":memory:")
+	db, err := sql.Open("sqlite3", tmp)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db.Close()
 
-	stmt, err := db.Prepare(`SELECT 1; -- HERE`)
-	if err != nil {
-		t.Error(err)
-	}
-	defer stmt.Close()
-
 	var serr *sqlite3.Error
 	_, err = db.Prepare(`SELECT`)
 	if err == nil {
@@ -206,18 +224,14 @@ func Test_Prepare(t *testing.T) {
 		t.Error("got message:", got)
 	}
 
+	_, err = db.Prepare(`SELECT 1; `)
+	if err != nil {
+		t.Error(err)
+	}
+
 	_, err = db.Prepare(`SELECT 1; SELECT`)
-	if err == nil {
-		t.Error("want error")
-	}
-	if !errors.As(err, &serr) {
-		t.Fatalf("got %T, want sqlite3.Error", err)
-	}
-	if rc := serr.Code(); rc != sqlite3.ERROR {
-		t.Errorf("got %d, want sqlite3.ERROR", rc)
-	}
-	if got := err.Error(); got != `sqlite3: SQL logic error: incomplete input` {
-		t.Error("got message:", got)
+	if err.Error() != string(util.TailErr) {
+		t.Error("want tailErr")
 	}
 
 	_, err = db.Prepare(`SELECT 1; SELECT 2`)
@@ -228,11 +242,12 @@ func Test_Prepare(t *testing.T) {
 
 func Test_QueryRow_named(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	db, err := sql.Open("sqlite3", ":memory:")
+	db, err := sql.Open("sqlite3", tmp)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -280,8 +295,9 @@ func Test_QueryRow_named(t *testing.T) {
 
 func Test_QueryRow_blob_null(t *testing.T) {
 	t.Parallel()
+	tmp := memdb.TestDB(t)
 
-	db, err := sql.Open("sqlite3", ":memory:")
+	db, err := sql.Open("sqlite3", tmp)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -296,6 +312,7 @@ func Test_QueryRow_blob_null(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	defer rows.Close()
 
 	want := [][]byte{nil, {0xca, 0xfe}, {0xba, 0xbe}, nil}
 	for i := 0; rows.Next(); i++ {
@@ -309,3 +326,144 @@ func Test_QueryRow_blob_null(t *testing.T) {
 		}
 	}
 }
+
+func Test_time(t *testing.T) {
+	t.Parallel()
+
+	for _, fmt := range []string{"auto", "sqlite", "rfc3339", time.ANSIC} {
+		t.Run(fmt, func(t *testing.T) {
+			tmp := memdb.TestDB(t, url.Values{
+				"_timefmt": {fmt},
+			})
+
+			db, err := sql.Open("sqlite3", tmp)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer db.Close()
+
+			twosday := time.Date(2022, 2, 22, 22, 22, 22, 0, time.UTC)
+
+			_, err = db.Exec(`CREATE TABLE test (at DATETIME)`)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			_, err = db.Exec(`INSERT INTO test VALUES (?)`, twosday)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			var got time.Time
+			err = db.QueryRow(`SELECT * FROM test`).Scan(&got)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if !got.Equal(twosday) {
+				t.Errorf("got: %v", got)
+			}
+		})
+	}
+}
+
+func Test_ColumnType_ScanType(t *testing.T) {
+	var (
+		INT  = reflect.TypeOf(int64(0))
+		REAL = reflect.TypeOf(float64(0))
+		TEXT = reflect.TypeOf("")
+		BLOB = reflect.TypeOf([]byte{})
+		BOOL = reflect.TypeOf(false)
+		TIME = reflect.TypeOf(time.Time{})
+		ANY  = reflect.TypeOf((*any)(nil)).Elem()
+	)
+
+	t.Parallel()
+	tmp := memdb.TestDB(t)
+
+	db, err := sql.Open("sqlite3", tmp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec(`
+		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.Query(`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)
+	}
+}

driver/example2_test.go

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

driver/example_test.go

@@ -1,3 +1,5 @@
+//go:build linux || darwin || windows || freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock || sqlite3_dotlk
+
 package driver_test
 
 // Adapted from: https://go.dev/doc/tutorial/database-access
@@ -10,6 +12,7 @@ import (
 
 	_ "github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
+	_ "github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
 var db *sql.DB

driver/json_test.go

@@ -0,0 +1,84 @@
+package driver_test
+
+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"
+)
+
+func Example_json() {
+	db, err := driver.Open("file:/json.db?vfs=memdb")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec(`
+		CREATE TABLE orders (
+			cart_id INTEGER PRIMARY KEY,
+			user_id INTEGER NOT NULL,
+			cart    BLOB -- stored as JSONB
+		) STRICT;
+	`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	type CartItem struct {
+		ItemID   string `json:"id"`
+		Name     string `json:"name"`
+		Quantity int    `json:"quantity,omitempty"`
+		Price    int    `json:"price,omitempty"`
+	}
+
+	type Cart struct {
+		Items []CartItem `json:"items"`
+	}
+
+	// convert to JSONB on insertion
+	_, err = db.Exec(`INSERT INTO orders (user_id, cart) VALUES (?, jsonb(?))`, 123, sqlite3.JSON(Cart{
+		[]CartItem{
+			{ItemID: "111", Name: "T-shirt", Quantity: 1, Price: 250},
+			{ItemID: "222", Name: "Trousers", Quantity: 1, Price: 600},
+		},
+	}))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	var total string
+	err = db.QueryRow(`
+		SELECT total(json_each.value -> 'price')
+		FROM orders, json_each(cart -> 'items')
+		WHERE cart_id = last_insert_rowid()
+	`).Scan(&total)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Println("total:", total)
+
+	var cart Cart
+	err = db.QueryRow(`
+		SELECT json(cart) -- convert to JSON on retrieval
+		FROM orders
+		WHERE cart_id = last_insert_rowid()
+	`).Scan(sqlite3.JSON(&cart))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	for _, item := range cart.Items {
+		fmt.Printf("id: %s, name: %s, quantity: %d, price: %d\n",
+			item.ItemID, item.Name, item.Quantity, item.Price)
+	}
+
+	// Output:
+	// total: 850
+	// id: 111, name: T-shirt, quantity: 1, price: 250
+	// id: 222, name: Trousers, quantity: 1, price: 600
+}

driver/savepoint.go

@@ -0,0 +1,40 @@
+package driver
+
+import (
+	"database/sql"
+	"time"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+// Savepoint establishes a new transaction savepoint.
+//
+// https://sqlite.org/lang_savepoint.html
+func Savepoint(tx *sql.Tx) sqlite3.Savepoint {
+	var ctx saveptCtx
+	tx.ExecContext(&ctx, "")
+	return ctx.Savepoint
+}
+
+// A saveptCtx is never canceled, has no values, and has no deadline.
+type saveptCtx struct{ sqlite3.Savepoint }
+
+func (*saveptCtx) Deadline() (deadline time.Time, ok bool) {
+	// notest
+	return
+}
+
+func (*saveptCtx) Done() <-chan struct{} {
+	// notest
+	return nil
+}
+
+func (*saveptCtx) Err() error {
+	// notest
+	return nil
+}
+
+func (*saveptCtx) Value(key any) any {
+	// notest
+	return nil
+}

driver/savepoint_test.go

@@ -0,0 +1,89 @@
+package driver_test
+
+import (
+	"fmt"
+	"log"
+
+	"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"
+)
+
+func ExampleSavepoint() {
+	db, err := driver.Open("file:/svpt.db?vfs=memdb")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec(`CREATE TABLE users (id INT, name VARCHAR(10))`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = func() error {
+		tx, err := db.Begin()
+		if err != nil {
+			return err
+		}
+		defer tx.Rollback()
+
+		stmt, err := tx.Prepare(`INSERT INTO users (id, name) VALUES (?, ?)`)
+		if err != nil {
+			return err
+		}
+		defer stmt.Close()
+
+		_, err = stmt.Exec(0, "go")
+		if err != nil {
+			return err
+		}
+
+		_, err = stmt.Exec(1, "zig")
+		if err != nil {
+			return err
+		}
+
+		savept := driver.Savepoint(tx)
+
+		_, err = stmt.Exec(2, "whatever")
+		if err != nil {
+			return err
+		}
+
+		err = savept.Rollback()
+		if err != nil {
+			return err
+		}
+
+		_, err = stmt.Exec(3, "rust")
+		if err != nil {
+			return err
+		}
+
+		return tx.Commit()
+	}()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	rows, err := db.Query(`SELECT id, name FROM users`)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var id, name string
+		err = rows.Scan(&id, &name)
+		if err != nil {
+			log.Fatal(err)
+		}
+		fmt.Printf("%s %s\n", id, name)
+	}
+	// Output:
+	// 0 go
+	// 1 zig
+	// 3 rust
+}

driver/time.go

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

driver/time_test.go

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

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

@@ -1,9 +1,13 @@
 package driver
 
 import (
+	"context"
 	"database/sql/driver"
 	"reflect"
 	"testing"
+
+	_ "github.com/ncruces/go-sqlite3/embed"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
 )
 
 func Test_namedValues(t *testing.T) {
@@ -16,3 +20,67 @@ func Test_namedValues(t *testing.T) {
 		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()
+		}
+
+		c, err := db.Conn(context.Background())
+		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
+		})
+	})
+}

driver_test.go

@@ -1,75 +0,0 @@
-package sqlite3_test
-
-import (
-	"context"
-	"database/sql"
-	"fmt"
-	"log"
-	"os"
-
-	"github.com/ncruces/go-sqlite3"
-	_ "github.com/ncruces/go-sqlite3/driver"
-	_ "github.com/ncruces/go-sqlite3/embed"
-)
-
-var db *sql.DB
-
-func ExampleDriverConn() {
-	var err error
-	db, err = sql.Open("sqlite3", "demo.db")
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer os.Remove("demo.db")
-	defer db.Close()
-
-	ctx := context.Background()
-
-	conn, err := db.Conn(ctx)
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer conn.Close()
-
-	_, err = conn.ExecContext(ctx, `CREATE TABLE IF NOT EXISTS test (col)`)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	res, err := conn.ExecContext(ctx, `INSERT INTO test VALUES (?)`, sqlite3.ZeroBlob(11))
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	id, err := res.LastInsertId()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	err = conn.Raw(func(driverConn any) error {
-		conn := driverConn.(sqlite3.DriverConn)
-		savept := conn.Savepoint()
-		defer savept.Release(&err)
-
-		blob, err := conn.OpenBlob("main", "test", "col", id, true)
-		if err != nil {
-			return err
-		}
-		defer blob.Close()
-
-		_, err = fmt.Fprint(blob, "Hello BLOB!")
-		return err
-	})
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	var msg string
-	err = conn.QueryRowContext(ctx, `SELECT col FROM test`).Scan(&msg)
-	if err != nil {
-		log.Fatal(err)
-	}
-	fmt.Println(msg)
-	// Output:
-	// Hello BLOB!
-}

embed/README.md

@@ -1,24 +1,41 @@
-# Embeddable WASM build of SQLite
+# Embeddable Wasm build of SQLite
 
-This folder includes an embeddable WASM build of SQLite 3.42.0 for use with
+This folder includes an embeddable Wasm build of SQLite 3.48.0 for use with
 [`github.com/ncruces/go-sqlite3`](https://pkg.go.dev/github.com/ncruces/go-sqlite3).
 
 The following optional features are compiled in:
-- [math functions](https://www.sqlite.org/lang_mathfunc.html)
-- [FTS3/4](https://www.sqlite.org/fts3.html)/[5](https://www.sqlite.org/fts5.html)
-- [JSON](https://www.sqlite.org/json1.html)
-- [R*Tree](https://www.sqlite.org/rtree.html)
-- [GeoPoly](https://www.sqlite.org/geopoly.html)
+- [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)
+- [Spellfix1](https://sqlite.org/spellfix1.html)
+- [soundex](https://sqlite.org/lang_corefunc.html#soundex)
+- [stat4](https://sqlite.org/compile.html#enable_stat4)
 - [base64](https://github.com/sqlite/sqlite/blob/master/ext/misc/base64.c)
 - [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)
-- [uuid](https://github.com/sqlite/sqlite/blob/master/ext/misc/uuid.c)
 - [time](../sqlite3/time.c)
 
-See the [configuration options](../sqlite3/sqlite_cfg.h),
+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).
+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://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

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

embed/bcw2/README.md

@@ -0,0 +1,22 @@
+# Embeddable Wasm build of SQLite
+
+This folder includes an alternative embeddable Wasm build of SQLite,
+which includes the experimental
+[`BEGIN CONCURRENT`](https://sqlite.org/src/doc/begin-concurrent/doc/begin_concurrent.md) and
+[Wal2](https://sqlite.org/cgi/src/doc/wal2/doc/wal2.md) patches.
+
+It also enables the optional
+[`UPDATE … ORDER BY … LIMIT`](https://sqlite.org/lang_update.html#optional_limit_and_order_by_clauses) and
+[`DELETE … ORDER BY … LIMIT`](https://sqlite.org/lang_delete.html#optional_limit_and_order_by_clauses) clauses,
+and the [`WITHIN GROUP ORDER BY`](https://sqlite.org/compile.html#enable_ordered_set_aggregates) aggregate syntax.
+
+> [!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 these 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

@@ -0,0 +1,59 @@
+package bcw2
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/ncruces/go-sqlite3/driver"
+	"github.com/ncruces/go-sqlite3/ext/stats"
+	"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", stats.Register)
+	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.Exec(`DELETE FROM test LIMIT 1`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = tx.Exec(`SELECT median() WITHIN GROUP (ORDER BY col) FROM test`)
+	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.48.0" {
+		t.Error(version)
+	}
+}

embed/bcw2/build.sh

@@ -0,0 +1,66 @@
+#!/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/
+
+# https://sqlite.org/src/info/fab341c829554573
+curl -# https://sqlite.org/src/tarball/sqlite.tar.gz?r=fab341c8 | tar xz
+
+cd sqlite
+if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" ]]; then
+	MSYS_NO_PATHCONV=1 nmake /f makefile.msc sqlite3.c "OPTS=-DSQLITE_ENABLE_UPDATE_DELETE_LIMIT -DSQLITE_ENABLE_ORDERED_SET_AGGREGATES"
+else
+	sh configure --enable-update-limit
+	OPTS=-DSQLITE_ENABLE_ORDERED_SET_AGGREGATES 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/spellfix.c   build/ext/
+mv sqlite/ext/misc/uint.c       build/ext/
+
+cd build
+cat *.patch | patch -p0 --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 \
+	-msimd128 -mmutable-globals -mmultivalue \
+	-mbulk-memory -mreference-types \
+	-mnontrapping-fptoint -msign-ext \
+	-fno-stack-protector -fno-stack-clash-protection \
+	-Wl,--stack-first \
+	-Wl,--import-undefined \
+	-Wl,--initial-memory=327680 \
+	-D_HAVE_SQLITE_CONFIG_H \
+	-DSQLITE_ENABLE_UPDATE_DELETE_LIMIT \
+	-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/go.mod

@@ -0,0 +1,14 @@
+module github.com/ncruces/go-sqlite3/embed/bcw2
+
+go 1.21
+
+toolchain go1.23.0
+
+require github.com/ncruces/go-sqlite3 v0.22.0
+
+require (
+	github.com/ncruces/julianday v1.0.0 // indirect
+	github.com/ncruces/sort v0.1.2 // indirect
+	github.com/tetratelabs/wazero v1.8.2 // indirect
+	golang.org/x/sys v0.29.0 // indirect
+)

embed/bcw2/go.sum

@@ -0,0 +1,12 @@
+github.com/ncruces/go-sqlite3 v0.22.0 h1:FkGSBhd0TY6e66k1LVhyEpA+RnG/8QkQNed5pjIk4cs=
+github.com/ncruces/go-sqlite3 v0.22.0/go.mod h1:ueXOZXYZS2OFQirCU3mHneDwJm5fGKHrtccYBeGEV7M=
+github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M=
+github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
+github.com/ncruces/sort v0.1.2 h1:zKQ9CA4fpHPF6xsUhRTfi5EEryspuBpe/QA4VWQOV1U=
+github.com/ncruces/sort v0.1.2/go.mod h1:vEJUTBJtebIuCMmXD18GKo5GJGhsay+xZFOoBEIXFmE=
+github.com/tetratelabs/wazero v1.8.2 h1:yIgLR/b2bN31bjxwXHD8a3d+BogigR952csSDdLYEv4=
+github.com/tetratelabs/wazero v1.8.2/go.mod h1:yAI0XTsMBhREkM/YDAK/zNou3GoiAce1P6+rp/wQhjs=
+golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
+golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=

embed/bcw2/init.go

@@ -0,0 +1,24 @@
+// 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://sqlite.org/cgi/src/doc/wal2/doc/wal2.md
+package bcw2
+
+import (
+	_ "embed"
+	"unsafe"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+//go:embed bcw2.wasm
+var binary string
+
+func init() {
+	sqlite3.Binary = unsafe.Slice(unsafe.StringData(binary), len(binary))
+}

embed/build.sh

@@ -4,26 +4,29 @@ set -euo pipefail
 cd -P -- "$(dirname -- "$0")"
 
 ROOT=../
-BINARYEN="$ROOT/tools/binaryen-version_114/bin"
-WASI_SDK="$ROOT/tools/wasi-sdk-20.0/bin"
+BINARYEN="$ROOT/tools/binaryen/bin"
+WASI_SDK="$ROOT/tools/wasi-sdk/bin"
 
-"$WASI_SDK/clang" --target=wasm32-wasi -flto -g0 -O2 \
+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 \
-	-msimd128 -mmutable-globals \
+	-msimd128 -mmutable-globals -mmultivalue \
 	-mbulk-memory -mreference-types \
 	-mnontrapping-fptoint -msign-ext \
 	-fno-stack-protector -fno-stack-clash-protection \
-	-Wl,--initial-memory=327680 \
 	-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)
 
-trap 'rm -f sqlite3.tmp' EXIT
 "$BINARYEN/wasm-ctor-eval" -g -c _initialize sqlite3.wasm -o sqlite3.tmp
-"$BINARYEN/wasm-opt" -g --strip -c -O3 \
+"$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
 	sqlite3.tmp -o sqlite3.wasm \
 	--enable-simd --enable-mutable-globals --enable-multivalue \
 	--enable-bulk-memory --enable-reference-types \

embed/exports.txt

@@ -1,74 +1,140 @@
-free
-malloc
-malloc_destructor
-sqlite3_errcode
-sqlite3_errstr
-sqlite3_errmsg
-sqlite3_error_offset
-sqlite3_open_v2
-sqlite3_close
-sqlite3_close_v2
-sqlite3_prepare_v3
-sqlite3_finalize
-sqlite3_reset
-sqlite3_step
-sqlite3_exec
-sqlite3_clear_bindings
+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_null
-sqlite3_bind_int64
-sqlite3_bind_double
-sqlite3_bind_text64
-sqlite3_bind_blob64
+sqlite3_bind_pointer_go
+sqlite3_bind_text_go
+sqlite3_bind_value
 sqlite3_bind_zeroblob64
-sqlite3_column_count
-sqlite3_column_name
-sqlite3_column_type
-sqlite3_column_int64
-sqlite3_column_double
-sqlite3_column_text
+sqlite3_blob_bytes
+sqlite3_blob_close
+sqlite3_blob_open
+sqlite3_blob_read
+sqlite3_blob_reopen
+sqlite3_blob_write
+sqlite3_busy_handler_go
+sqlite3_busy_timeout
+sqlite3_changes64
+sqlite3_clear_bindings
+sqlite3_close
+sqlite3_close_v2
+sqlite3_collation_needed_go
 sqlite3_column_blob
 sqlite3_column_bytes
-sqlite3_blob_open
-sqlite3_blob_close
-sqlite3_blob_reopen
-sqlite3_blob_bytes
-sqlite3_blob_read
-sqlite3_blob_write
-sqlite3_backup_init
-sqlite3_backup_step
-sqlite3_backup_finish
-sqlite3_backup_remaining
-sqlite3_backup_pagecount
-sqlite3_uri_parameter
-sqlite3_uri_key
-sqlite3_changes64
-sqlite3_last_insert_rowid
-sqlite3_get_autocommit
-sqlite3_anycollseq_init
+sqlite3_column_count
+sqlite3_column_database_name
+sqlite3_column_decltype
+sqlite3_column_double
+sqlite3_column_int64
+sqlite3_column_name
+sqlite3_column_origin_name
+sqlite3_column_table_name
+sqlite3_column_text
+sqlite3_column_type
+sqlite3_column_value
+sqlite3_columns_go
+sqlite3_commit_hook_go
+sqlite3_config_log_go
+sqlite3_create_aggregate_function_go
 sqlite3_create_collation_go
 sqlite3_create_function_go
-sqlite3_create_aggregate_function_go
+sqlite3_create_module_go
 sqlite3_create_window_function_go
-sqlite3_aggregate_context
-sqlite3_user_data
-sqlite3_set_auxdata_go
+sqlite3_data_count
+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_value_type
-sqlite3_value_int64
-sqlite3_value_double
-sqlite3_value_text
-sqlite3_value_blob
-sqlite3_value_bytes
-sqlite3_result_null
-sqlite3_result_int64
+sqlite3_hard_heap_limit64
+sqlite3_interrupt
+sqlite3_invoke_busy_handler_go
+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_text64
-sqlite3_result_blob64
-sqlite3_result_zeroblob64
 sqlite3_result_error
 sqlite3_result_error_code
 sqlite3_result_error_nomem
-sqlite3_result_error_toobig
+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

@@ -8,13 +8,14 @@ package embed
 
 import (
 	_ "embed"
+	"unsafe"
 
 	"github.com/ncruces/go-sqlite3"
 )
 
 //go:embed sqlite3.wasm
-var binary []byte
+var binary string
 
 func init() {
-	sqlite3.Binary = binary
+	sqlite3.Binary = unsafe.Slice(unsafe.StringData(binary), len(binary))
 }

embed/init_test.go

@@ -0,0 +1,25 @@
+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.48.0" {
+		t.Error(version)
+	}
+}

error.go

@@ -1,6 +1,7 @@
 package sqlite3
 
 import (
+	"errors"
 	"strconv"
 	"strings"
 
@@ -9,7 +10,7 @@ import (
 
 // Error wraps an SQLite Error Code.
 //
-// https://www.sqlite.org/c3ref/errcode.html
+// https://sqlite.org/c3ref/errcode.html
 type Error struct {
 	str  string
 	msg  string
@@ -19,14 +20,14 @@ type Error struct {
 
 // Code returns the primary error code for this error.
 //
-// https://www.sqlite.org/rescode.html
+// https://sqlite.org/rescode.html
 func (e *Error) Code() ErrorCode {
 	return ErrorCode(e.code)
 }
 
 // ExtendedCode returns the extended error code for this error.
 //
-// https://www.sqlite.org/rescode.html
+// https://sqlite.org/rescode.html
 func (e *Error) ExtendedCode() ExtendedErrorCode {
 	return ExtendedErrorCode(e.code)
 }
@@ -43,8 +44,7 @@ func (e *Error) Error() string {
 	}
 
 	if e.msg != "" {
-		b.WriteByte(':')
-		b.WriteByte(' ')
+		b.WriteString(": ")
 		b.WriteString(e.msg)
 	}
 
@@ -106,6 +106,11 @@ func (e ErrorCode) Temporary() bool {
 	return e == BUSY
 }
 
+// ExtendedCode returns the extended error code for this error.
+func (e ErrorCode) ExtendedCode() ExtendedErrorCode {
+	return ExtendedErrorCode(e)
+}
+
 // Error implements the error interface.
 func (e ExtendedErrorCode) Error() string {
 	return util.ErrorCodeString(uint32(e))
@@ -135,3 +140,33 @@ func (e ExtendedErrorCode) Temporary() bool {
 func (e ExtendedErrorCode) Timeout() bool {
 	return e == BUSY_TIMEOUT
 }
+
+// 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 uint32) {
+	switch code := err.(type) {
+	case nil:
+		return "", _OK
+	case ErrorCode:
+		return "", uint32(code)
+	case xErrorCode:
+		return "", uint32(code)
+	case *Error:
+		return code.msg, uint32(code.code)
+	}
+
+	var ecode ErrorCode
+	var xcode xErrorCode
+	switch {
+	case errors.As(err, &xcode):
+		code = uint32(xcode)
+	case errors.As(err, &ecode):
+		code = uint32(ecode)
+	default:
+		code = uint32(def)
+	}
+	return err.Error(), code
+}

error_test.go

@@ -2,6 +2,7 @@ package sqlite3
 
 import (
 	"errors"
+	"fmt"
 	"strings"
 	"testing"
 
@@ -10,7 +11,7 @@ import (
 
 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:12)") {
+	if s := err.Error(); !strings.HasPrefix(s, "sqlite3: assertion failed") || !strings.HasSuffix(s, "error_test.go:13)") {
 		t.Errorf("got %q", s)
 	}
 }
@@ -135,8 +136,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(db.api.errstr, uint64(i))
-		want += util.ReadString(db.mod, uint32(r), _MAX_STRING)
+		r := db.call("sqlite3_errstr", uint64(i))
+		want += util.ReadString(db.mod, uint32(r), _MAX_NAME)
 
 		got := ErrorCode(i).Error()
 		if got != want {
@@ -157,8 +158,8 @@ func Test_ExtendedErrorCode_Error(t *testing.T) {
 	// Test all extended error codes.
 	for i := 0; i == int(ExtendedErrorCode(i)); i++ {
 		want := "sqlite3: "
-		r := db.call(db.api.errstr, uint64(i))
-		want += util.ReadString(db.mod, uint32(r), _MAX_STRING)
+		r := db.call("sqlite3_errstr", uint64(i))
+		want += util.ReadString(db.mod, uint32(r), _MAX_NAME)
 
 		got := ExtendedErrorCode(i).Error()
 		if got != want {
@@ -166,3 +167,32 @@ func Test_ExtendedErrorCode_Error(t *testing.T) {
 		}
 	}
 }
+
+func Test_errorCode(t *testing.T) {
+	tests := []struct {
+		arg      error
+		wantMsg  string
+		wantCode uint32
+	}{
+		{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},
+	}
+	for _, tt := range tests {
+		t.Run("", func(t *testing.T) {
+			gotMsg, gotCode := errorCode(tt.arg, ERROR)
+			if gotMsg != tt.wantMsg {
+				t.Errorf("errorCode() gotMsg = %q, want %q", gotMsg, tt.wantMsg)
+			}
+			if gotCode != uint32(tt.wantCode) {
+				t.Errorf("errorCode() gotCode = %d, want %d", gotCode, tt.wantCode)
+			}
+		})
+	}
+}

example_test.go

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

ext/README.md

@@ -0,0 +1,37 @@
+# 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/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.

ext/array/array.go

@@ -0,0 +1,136 @@
+// Package array provides the array table-valued SQL function.
+//
+// https://sqlite.org/carray.html
+package array
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
+)
+
+// Register registers the array single-argument, table-valued SQL function.
+// The argument must be bound to a Go slice or array of
+// ints, floats, bools, strings or byte slices,
+// using [sqlite3.BindPointer] or [sqlite3.Pointer].
+func Register(db *sqlite3.Conn) error {
+	return sqlite3.CreateModule(db, "array", nil,
+		func(db *sqlite3.Conn, _, _, _ string, _ ...string) (array, error) {
+			err := db.DeclareVTab(`CREATE TABLE x(value, array HIDDEN)`)
+			return array{}, err
+		})
+}
+
+type array struct{}
+
+func (array) BestIndex(idx *sqlite3.IndexInfo) error {
+	for i, cst := range idx.Constraint {
+		if cst.Column == 1 && cst.Op == sqlite3.INDEX_CONSTRAINT_EQ && cst.Usable {
+			idx.ConstraintUsage[i] = sqlite3.IndexConstraintUsage{
+				Omit:      true,
+				ArgvIndex: 1,
+			}
+			idx.EstimatedCost = 1
+			idx.EstimatedRows = 100
+			return nil
+		}
+	}
+	return sqlite3.CONSTRAINT
+}
+
+func (array) Open() (sqlite3.VTabCursor, error) {
+	return &cursor{}, nil
+}
+
+type cursor struct {
+	array reflect.Value
+	rowID int
+}
+
+func (c *cursor) EOF() bool {
+	return c.rowID >= c.array.Len()
+}
+
+func (c *cursor) Next() error {
+	c.rowID++
+	return nil
+}
+
+func (c *cursor) RowID() (int64, error) {
+	return int64(c.rowID), nil
+}
+
+func (c *cursor) Column(ctx sqlite3.Context, n int) error {
+	if n != 0 {
+		return nil
+	}
+
+	v := c.array.Index(c.rowID)
+	k := v.Kind()
+
+	if k == reflect.Interface {
+		if v.IsNil() {
+			ctx.ResultNull()
+			return nil
+		}
+		v = v.Elem()
+		k = v.Kind()
+	}
+
+	switch {
+	case v.CanInt():
+		ctx.ResultInt64(v.Int())
+
+	case v.CanUint():
+		i64 := int64(v.Uint())
+		if i64 < 0 {
+			return fmt.Errorf("array: integer element overflow:%.0w %d", sqlite3.MISMATCH, v.Uint())
+		}
+		ctx.ResultInt64(i64)
+
+	case v.CanFloat():
+		ctx.ResultFloat(v.Float())
+
+	case k == reflect.Bool:
+		ctx.ResultBool(v.Bool())
+
+	case k == reflect.String:
+		ctx.ResultText(v.String())
+
+	case (k == reflect.Slice || k == reflect.Array && v.CanAddr()) &&
+		v.Type().Elem().Kind() == reflect.Uint8:
+		ctx.ResultBlob(v.Bytes())
+
+	default:
+		return fmt.Errorf("array: unsupported element:%.0w %v", sqlite3.MISMATCH, util.ReflectType(v))
+	}
+	return nil
+}
+
+func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
+	array := reflect.ValueOf(arg[0].Pointer())
+	array, err := indexable(array)
+	if err != nil {
+		return err
+	}
+
+	c.array = array
+	c.rowID = 0
+	return nil
+}
+
+func indexable(v reflect.Value) (reflect.Value, error) {
+	switch v.Kind() {
+	case reflect.Slice:
+		return v, nil
+	case reflect.Array:
+		return v, nil
+	case reflect.Pointer:
+		if v := v.Elem(); v.Kind() == reflect.Array {
+			return v, nil
+		}
+	}
+	return v, fmt.Errorf("array: unsupported argument:%.0w %v", sqlite3.MISMATCH, util.ReflectType(v))
+}

ext/array/array_test.go

@@ -0,0 +1,156 @@
+package array_test
+
+import (
+	"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"
+)
+
+func Example_driver() {
+	db, err := driver.Open("file:/test.db?vfs=memdb", array.Register)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	rows, err := db.Query(`
+		SELECT name
+		FROM pragma_function_list
+		WHERE name like 'geopoly%' AND narg IN array(?)`,
+		sqlite3.Pointer([]int{2, 3, 4}))
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var name string
+		err := rows.Scan(&name)
+		if err != nil {
+			log.Fatal(err)
+		}
+		fmt.Printf("%s\n", name)
+	}
+	if err := rows.Err(); err != nil {
+		log.Fatal(err)
+	}
+	// Unordered output:
+	// geopoly_regular
+	// geopoly_overlap
+	// geopoly_contains_point
+	// geopoly_within
+}
+
+func Example() {
+	sqlite3.AutoExtension(array.Register)
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	stmt, _, err := db.Prepare(`
+		SELECT name
+		FROM pragma_function_list
+		WHERE name like 'geopoly%' AND narg IN array(?)`)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer stmt.Close()
+
+	err = stmt.BindPointer(1, [...]int{2, 3, 4})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	for stmt.Step() {
+		fmt.Printf("%s\n", stmt.ColumnText(0))
+	}
+	if err := stmt.Err(); err != nil {
+		log.Fatal(err)
+	}
+	// Unordered output:
+	// geopoly_regular
+	// geopoly_overlap
+	// geopoly_contains_point
+	// geopoly_within
+}
+
+func Test_cursor_Column(t *testing.T) {
+	t.Parallel()
+	tmp := memdb.TestDB(t)
+
+	db, err := driver.Open(tmp, array.Register)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	rows, err := db.Query(`
+		SELECT rowid, value FROM array(?)`,
+		sqlite3.Pointer(&[...]any{nil, true, 1, uint(2), math.Pi, "text", []byte{1, 2, 3}}))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer rows.Close()
+
+	want := []string{"nil", "int64", "int64", "int64", "float64", "string", "[]uint8"}
+
+	for rows.Next() {
+		var id, val any
+		err := rows.Scan(&id, &val)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if want := want[0]; val == nil {
+			if want != "nil" {
+				t.Errorf("got nil, want %s", want)
+			}
+		} else if got := reflect.TypeOf(val).String(); got != want {
+			t.Errorf("got %s, want %s", got, want)
+		}
+		want = want[1:]
+	}
+	if err := rows.Err(); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func Test_array_errors(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = array.Register(db)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`SELECT * FROM array()`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`SELECT * FROM array(?)`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+}

ext/blobio/blob.go

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

ext/blobio/blob_test.go

@@ -0,0 +1,284 @@
+package blobio_test
+
+import (
+	"io"
+	"log"
+	"os"
+	"reflect"
+	"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"
+)
+
+func Example() {
+	// Open the database, registering the extension.
+	db, err := driver.Open("file:/test.db?vfs=memdb", blobio.Register)
+
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec(`CREATE TABLE test (col)`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	const message = "Hello BLOB!"
+
+	// Create the BLOB.
+	r, err := db.Exec(`INSERT INTO test VALUES (?)`, sqlite3.ZeroBlob(len(message)))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	id, err := r.LastInsertId()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Write the BLOB.
+	_, err = db.Exec(`SELECT writeblob('main', 'test', 'col', ?, 0, ?)`,
+		id, message)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Read the BLOB.
+	_, err = db.Exec(`SELECT readblob('main', 'test', 'col', ?, 0, ?)`,
+		id, sqlite3.Pointer(os.Stdout))
+	if err != nil {
+		log.Fatal(err)
+	}
+	// Output:
+	// Hello BLOB!
+}
+
+func TestMain(m *testing.M) {
+	sqlite3.AutoExtension(blobio.Register)
+	sqlite3.AutoExtension(array.Register)
+	m.Run()
+}
+
+func Test_readblob(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Exec(`SELECT readblob()`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`SELECT readblob('main', 'test1', 'col', 1, 1, 1)`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`
+		CREATE TABLE test1 (col);
+		CREATE TABLE test2 (col);
+		INSERT INTO test1 VALUES (x'cafe');
+		INSERT INTO test1 VALUES (x'dead');
+		INSERT INTO test2 VALUES (x'babe');
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`SELECT readblob('main', 'test1', 'col', 1, -1, 1)`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`SELECT readblob('main', 'test1', 'col', 1, 1, 0)`)
+	if err != nil {
+		t.Log(err)
+	}
+
+	tests := []struct {
+		name  string
+		sql   string
+		want1 string
+		want2 string
+	}{
+		{"rows", `SELECT readblob('main', 'test1', 'col', rowid, 1, 1) FROM test1`, "\xfe", "\xad"},
+		{"tables", `SELECT readblob('main', value, 'col', 1, 1, 1) FROM array(?)`, "\xfe", "\xbe"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			stmt, _, err := db.Prepare(tt.sql)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer stmt.Close()
+
+			if stmt.BindCount() == 1 {
+				err = stmt.BindPointer(1, []string{"test1", "test2"})
+				if err != nil {
+					t.Fatal(err)
+				}
+			}
+
+			if stmt.Step() {
+				got := stmt.ColumnText(0)
+				if got != tt.want1 {
+					t.Errorf("got %q", got)
+				}
+			}
+
+			if stmt.Step() {
+				got := stmt.ColumnText(0)
+				if got != tt.want2 {
+					t.Errorf("got %q", got)
+				}
+			}
+
+			err = stmt.Err()
+			if err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func Test_writeblob(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Exec(`SELECT writeblob()`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`SELECT writeblob('main', 'test', 'col', 1, 1, x'')`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`
+		CREATE TABLE test (col);
+		INSERT INTO test VALUES (x'cafe');
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`SELECT writeblob('main', 'test', 'col', 1, -1, x'')`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT writeblob('main', 'test', 'col', 1, 0, ?)`)
+	if err != nil {
+		t.Log(err)
+	}
+	defer stmt.Close()
+
+	err = stmt.BindPointer(1, strings.NewReader("\xba\xbe"))
+	if err != nil {
+		t.Log(err)
+	}
+
+	err = stmt.Exec()
+	if err != nil {
+		t.Log(err)
+	}
+}
+
+func Test_openblob(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Exec(`SELECT openblob()`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`SELECT openblob('main', 'test1', 'col', 1, false, NULL)`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`
+		CREATE TABLE test1 (col);
+		CREATE TABLE test2 (col);
+		INSERT INTO test1 VALUES (x'cafe');
+		INSERT INTO test2 VALUES (x'babe');
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT openblob('main', value, 'col', 1, false, ?) FROM array(?)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer stmt.Close()
+
+	var got []string
+	err = stmt.BindPointer(1, blobio.OpenCallback(func(b *sqlite3.Blob, _ ...sqlite3.Value) error {
+		d, err := io.ReadAll(b)
+		if err != nil {
+			return err
+		}
+		got = append(got, string(d))
+		return nil
+	}))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = stmt.BindPointer(2, []string{"test1", "test2"})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = stmt.Exec()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want := []string{"\xca\xfe", "\xba\xbe"}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("got %v, want %v", got, want)
+	}
+}

ext/bloom/bloom.go

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

ext/bloom/bloom_test.go

@@ -0,0 +1,195 @@
+package bloom_test
+
+import (
+	_ "embed"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+	_ "github.com/ncruces/go-sqlite3/embed"
+	"github.com/ncruces/go-sqlite3/ext/bloom"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+)
+
+func TestMain(m *testing.M) {
+	sqlite3.AutoExtension(bloom.Register)
+	m.Run()
+}
+
+func TestRegister(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Exec(`
+		CREATE VIRTUAL TABLE sports_cars USING bloom_filter();
+		INSERT INTO sports_cars VALUES ('ferrari'), ('lamborghini'), ('alfa romeo')
+	`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	query, _, err := db.Prepare(`SELECT COUNT(*) FROM sports_cars(?)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = query.BindText(1, "ferrari")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !query.Step() {
+		t.Error("no rows")
+	}
+	if !query.ColumnBool(0) {
+		t.Error("want true")
+	}
+	err = query.Reset()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = query.BindText(1, "bmw")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !query.Step() {
+		t.Error("no rows")
+	}
+	if query.ColumnBool(0) {
+		t.Error("want false")
+	}
+	err = query.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`DELETE FROM sports_cars WHERE word = 'lamborghini'`)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	err = db.Exec(`UPDATE sports_cars SET word = 'ferrari' WHERE word = 'lamborghini'`)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	err = db.Exec(`ALTER TABLE sports_cars RENAME TO fast_cars`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`DROP TABLE fast_cars`)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+//go:embed testdata/bloom.db
+var testDB []byte
+
+func Test_compatible(t *testing.T) {
+	t.Parallel()
+
+	tmp := filepath.Join(t.TempDir(), "bloom.db")
+	err := os.WriteFile(tmp, testDB, 0666)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	db, err := sqlite3.Open("file:" + filepath.ToSlash(tmp) + "?nolock=1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	query, _, err := db.Prepare(`SELECT COUNT(*) FROM plants(?)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer query.Close()
+
+	err = query.BindText(1, "apple")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !query.Step() {
+		t.Error("no rows")
+	}
+	if !query.ColumnBool(0) {
+		t.Error("want true")
+	}
+	err = query.Reset()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = query.BindText(1, "lemon")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !query.Step() {
+		t.Error("no rows")
+	}
+	if query.ColumnBool(0) {
+		t.Error("want false")
+	}
+	err = query.Reset()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`PRAGMA integrity_check`)
+	if err != nil {
+		t.Error(err)
+	}
+
+	err = db.Exec(`PRAGMA quick_check`)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func Test_errors(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	bloom.Register(db)
+
+	err = db.Exec(`CREATE VIRTUAL TABLE sports_cars USING bloom_filter(0)`)
+	if err == nil {
+		t.Error("want error")
+	}
+	err = db.Exec(`CREATE VIRTUAL TABLE sports_cars USING bloom_filter('a')`)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE sports_cars USING bloom_filter(20, 2)`)
+	if err == nil {
+		t.Error("want error")
+	}
+	err = db.Exec(`CREATE VIRTUAL TABLE sports_cars USING bloom_filter(20, 'a')`)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE sports_cars USING bloom_filter(20, 0.9, 0)`)
+	if err == nil {
+		t.Error("want error")
+	}
+	err = db.Exec(`CREATE VIRTUAL TABLE sports_cars USING bloom_filter(20, 0.9, 'a')`)
+	if err == nil {
+		t.Error("want error")
+	}
+}

ext/closure/closure.go

@@ -0,0 +1,260 @@
+// Package closure provides a transitive closure virtual table.
+//
+// The transitive_closure virtual table finds the transitive closure of
+// a parent/child relationship in a real table.
+//
+// https://sqlite.org/src/doc/tip/ext/misc/closure.c
+package closure
+
+import (
+	"fmt"
+	"math"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/ncruces/go-sqlite3/util/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,depth,root HIDDEN,tablename HIDDEN,idcolumn HIDDEN,parentcolumn HIDDEN)`)
+			if err != nil {
+				return nil, err
+			}
+			return &closure{
+				db:     db,
+				table:  table,
+				column: column,
+				parent: parent,
+			}, nil
+		})
+}
+
+type closure struct {
+	db     *sqlite3.Conn
+	table  string
+	column string
+	parent string
+}
+
+func (c *closure) Destroy() error { return nil }
+
+func (c *closure) BestIndex(idx *sqlite3.IndexInfo) error {
+	plan := 0
+	posi := 1
+	cost := 1e7
+
+	for i, cst := range idx.Constraint {
+		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.EstimatedCost = cost
+	idx.IdxNum = plan
+	return nil
+}
+
+func (c *closure) Open() (sqlite3.VTabCursor, error) {
+	return &cursor{closure: c}, nil
+}
+
+type cursor struct {
+	*closure
+	nodes []node
+}
+
+type node struct {
+	id    int64
+	depth int
+}
+
+func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
+	root := arg[0].Int64()
+	maxDepth := math.MaxInt
+	if idxNum&0xf0 != 0 {
+		maxDepth = arg[(idxNum>>4)&0xf].Int()
+		if idxNum&2 != 0 {
+			maxDepth -= 1
+		}
+	}
+	table := c.table
+	if idxNum&0xf00 != 0 {
+		table = arg[(idxNum>>8)&0xf].Text()
+	}
+	column := c.column
+	if idxNum&0xf000 != 0 {
+		column = arg[(idxNum>>12)&0xf].Text()
+	}
+	parent := c.parent
+	if idxNum&0xf0000 != 0 {
+		parent = arg[(idxNum>>16)&0xf].Text()
+	}
+
+	sql := fmt.Sprintf(
+		`SELECT %[1]s.%[2]s FROM %[1]s WHERE %[1]s.%[3]s=?`,
+		sqlite3.QuoteIdentifier(table),
+		sqlite3.QuoteIdentifier(column),
+		sqlite3.QuoteIdentifier(parent),
+	)
+	stmt, _, err := c.db.Prepare(sql)
+	if err != nil {
+		return err
+	}
+	defer stmt.Close()
+
+	c.nodes = []node{{root, 0}}
+	set := util.Set[int64]{}
+	set.Add(root)
+	for i := 0; i < len(c.nodes); i++ {
+		curr := c.nodes[i]
+		if curr.depth >= maxDepth {
+			continue
+		}
+		stmt.BindInt64(1, curr.id)
+		for stmt.Step() {
+			if stmt.ColumnType(0) == sqlite3.INTEGER {
+				next := stmt.ColumnInt64(0)
+				if !set.Contains(next) {
+					set.Add(next)
+					c.nodes = append(c.nodes, node{next, curr.depth + 1})
+				}
+			}
+		}
+		stmt.Reset()
+	}
+	return nil
+}
+
+func (c *cursor) Column(ctx sqlite3.Context, n int) error {
+	switch n {
+	case _COL_ID:
+		ctx.ResultInt64(c.nodes[0].id)
+	case _COL_DEPTH:
+		ctx.ResultInt(c.nodes[0].depth)
+	case _COL_TABLENAME:
+		ctx.ResultText(c.table)
+	case _COL_IDCOLUMN:
+		ctx.ResultText(c.column)
+	case _COL_PARENTCOLUMN:
+		ctx.ResultText(c.parent)
+	}
+	return nil
+}
+
+func (c *cursor) Next() error {
+	c.nodes = c.nodes[1:]
+	return nil
+}
+
+func (c *cursor) EOF() bool {
+	return len(c.nodes) == 0
+}
+
+func (c *cursor) RowID() (int64, error) {
+	return c.nodes[0].id, nil
+}

ext/closure/closure_test.go

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

ext/csv/arg.go

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

ext/csv/arg_test.go

@@ -0,0 +1,112 @@
+package csv
+
+import (
+	"testing"
+
+	"github.com/ncruces/go-sqlite3/util/sql3util"
+)
+
+func Test_uintArg(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		arg string
+		key string
+		val int
+		err bool
+	}{
+		{"columns 1", "columns 1", 0, true},
+		{"columns  = 1", "columns", 1, false},
+		{"columns\t= 2", "columns", 2, false},
+		{" columns = 3", "columns", 3, false},
+		{" columns = -1", "columns", 0, true},
+		{" columns = 32768", "columns", 0, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.arg, func(t *testing.T) {
+			key, val := sql3util.NamedArg(tt.arg)
+			if key != tt.key {
+				t.Errorf("NamedArg() %v, want err %v", key, tt.key)
+			}
+			got, err := uintArg(key, val)
+			if (err != nil) != tt.err {
+				t.Fatalf("uintArg() error = %v, want err %v", err, tt.err)
+			}
+			if got != tt.val {
+				t.Errorf("uintArg() = %v, want %v", got, tt.val)
+			}
+		})
+	}
+}
+
+func Test_boolArg(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		arg string
+		key string
+		val bool
+		err bool
+	}{
+		{"header", "header", true, false},
+		{"header\t= 1", "header", true, false},
+		{" header = 0", "header", false, false},
+		{" header = TrUe", "header", true, false},
+		{" header = FaLsE", "header", false, false},
+		{" header = Yes", "header", true, false},
+		{" header = nO", "header", false, false},
+		{" header = On", "header", true, false},
+		{" header = Off", "header", false, false},
+		{" header = T", "header", false, true},
+		{" header = f", "header", false, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.arg, func(t *testing.T) {
+			key, val := sql3util.NamedArg(tt.arg)
+			if key != tt.key {
+				t.Errorf("NamedArg() %v, want err %v", key, tt.key)
+			}
+			got, err := boolArg(key, val)
+			if (err != nil) != tt.err {
+				t.Fatalf("boolArg() error = %v, want err %v", err, tt.err)
+			}
+			if got != tt.val {
+				t.Errorf("boolArg() = %v, want %v", got, tt.val)
+			}
+		})
+	}
+}
+
+func Test_runeArg(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		arg string
+		key string
+		val rune
+		err bool
+	}{
+		{"comma", "comma", 0, true},
+		{"comma\t= ,", "comma", ',', false},
+		{" comma = ;", "comma", ';', false},
+		{" comma = ;;", "comma", 0, true},
+		{` comma = '\t`, "comma", 0, true},
+		{` comma = '\t'`, "comma", '\t', false},
+		{` comma = "\t"`, "comma", '\t', false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.arg, func(t *testing.T) {
+			key, val := sql3util.NamedArg(tt.arg)
+			if key != tt.key {
+				t.Errorf("NamedArg() %v, want err %v", key, tt.key)
+			}
+			got, err := runeArg(key, val)
+			if (err != nil) != tt.err {
+				t.Fatalf("runeArg() error = %v, want err %v", err, tt.err)
+			}
+			if got != tt.val {
+				t.Errorf("runeArg() = %v, want %v", got, tt.val)
+			}
+		})
+	}
+}

ext/csv/csv.go

@@ -0,0 +1,274 @@
+// Package csv provides a CSV virtual table.
+//
+// The CSV virtual table reads RFC 4180 formatted comma-separated values,
+// and returns that content as if it were rows and columns of an SQL table.
+//
+// https://sqlite.org/csv.html
+package csv
+
+import (
+	"bufio"
+	"encoding/csv"
+	"fmt"
+	"io"
+	"io/fs"
+	"strconv"
+	"strings"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/ncruces/go-sqlite3/util/osutil"
+	"github.com/ncruces/go-sqlite3/util/sql3util"
+)
+
+// Register registers the CSV virtual table.
+// If a filename is specified, [os.Open] is used to open the file.
+func Register(db *sqlite3.Conn) error {
+	return RegisterFS(db, osutil.FS{})
+}
+
+// RegisterFS registers the CSV virtual table.
+// If a filename is specified, fsys is used to open the file.
+func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
+	declare := func(db *sqlite3.Conn, _, _, _ string, arg ...string) (res *table, err error) {
+		var (
+			filename string
+			data     string
+			schema   string
+			header   bool
+			columns  int  = -1
+			comma    rune = ','
+			comment  rune
+
+			done = util.Set[string]{}
+		)
+
+		for _, arg := range arg {
+			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 = sql3util.Unquote(val)
+			case "data":
+				data = sql3util.Unquote(val)
+			case "schema":
+				schema = sql3util.Unquote(val)
+			case "header":
+				header, err = boolArg(key, val)
+			case "columns":
+				columns, err = uintArg(key, val)
+			case "comma":
+				comma, err = runeArg(key, val)
+			case "comment":
+				comment, err = runeArg(key, val)
+			default:
+				return nil, fmt.Errorf("csv: unknown %q parameter", key)
+			}
+			if err != nil {
+				return nil, err
+			}
+			done.Add(key)
+		}
+
+		if (filename == "") == (data == "") {
+			return nil, util.ErrorString(`csv: must specify either "filename" or "data" but not both`)
+		}
+
+		t := &table{
+			fsys:    fsys,
+			name:    filename,
+			data:    data,
+			comma:   comma,
+			comment: comment,
+			header:  header,
+		}
+
+		if schema == "" {
+			var row []string
+			if header || columns < 0 {
+				csv, c, err := t.newReader()
+				defer c.Close()
+				if err != nil {
+					return nil, err
+				}
+				row, err = csv.Read()
+				if err != nil {
+					return nil, err
+				}
+			}
+			schema = getSchema(header, columns, row)
+		} else {
+			t.typs, err = getColumnAffinities(schema)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		err = db.DeclareVTab(schema)
+		if err == nil {
+			err = db.VTabConfig(sqlite3.VTAB_DIRECTONLY)
+		}
+		if err != nil {
+			return nil, err
+		}
+		return t, nil
+	}
+
+	return sqlite3.CreateModule(db, "csv", declare, declare)
+}
+
+type table struct {
+	fsys    fs.FS
+	name    string
+	data    string
+	typs    []affinity
+	comma   rune
+	comment rune
+	header  bool
+}
+
+func (t *table) BestIndex(idx *sqlite3.IndexInfo) error {
+	idx.EstimatedCost = 1e6
+	return nil
+}
+
+func (t *table) Open() (sqlite3.VTabCursor, error) {
+	return &cursor{table: t}, nil
+}
+
+func (t *table) Rename(new string) error {
+	return nil
+}
+
+func (t *table) Integrity(schema, table string, flags int) error {
+	if flags&1 != 0 {
+		return nil
+	}
+	csv, c, err := t.newReader()
+	if err != nil {
+		return err
+	}
+	defer c.Close()
+	_, err = csv.ReadAll()
+	return err
+}
+
+func (t *table) newReader() (*csv.Reader, io.Closer, error) {
+	var r io.Reader
+	var c io.Closer
+	if t.name != "" {
+		f, err := t.fsys.Open(t.name)
+		if err != nil {
+			return nil, f, err
+		}
+
+		buf := bufio.NewReader(f)
+		bom, err := buf.Peek(3)
+		if err != nil {
+			return nil, f, err
+		}
+		if string(bom) == "\xEF\xBB\xBF" {
+			buf.Discard(3)
+		}
+
+		r = buf
+		c = f
+	} else {
+		r = strings.NewReader(t.data)
+		c = io.NopCloser(r)
+	}
+
+	csv := csv.NewReader(r)
+	csv.ReuseRecord = true
+	csv.Comma = t.comma
+	csv.Comment = t.comment
+	return csv, c, nil
+}
+
+type cursor struct {
+	table  *table
+	closer io.Closer
+	csv    *csv.Reader
+	row    []string
+	rowID  int64
+}
+
+func (c *cursor) Close() (err error) {
+	if c.closer != nil {
+		err = c.closer.Close()
+		c.closer = nil
+	}
+	return err
+}
+
+func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
+	err := c.Close()
+	if err != nil {
+		return err
+	}
+
+	c.csv, c.closer, err = c.table.newReader()
+	if err != nil {
+		return err
+	}
+	if c.table.header {
+		c.Next() // skip header
+	}
+	c.rowID = 0
+	return c.Next()
+}
+
+func (c *cursor) Next() (err error) {
+	c.rowID++
+	c.row, err = c.csv.Read()
+	if err != io.EOF {
+		return err
+	}
+	return nil
+}
+
+func (c *cursor) EOF() bool {
+	return c.row == nil
+}
+
+func (c *cursor) RowID() (int64, error) {
+	return c.rowID, nil
+}
+
+func (c *cursor) Column(ctx sqlite3.Context, col int) error {
+	if col < len(c.row) {
+		typ := text
+		if col < len(c.table.typs) {
+			typ = c.table.typs[col]
+		}
+
+		txt := c.row[col]
+		if txt == "" && typ != text {
+			return nil
+		}
+
+		switch typ {
+		case numeric, integer:
+			if strings.TrimLeft(txt, "+-0123456789") == "" {
+				if i, err := strconv.ParseInt(txt, 10, 64); err == nil {
+					ctx.ResultInt64(i)
+					return nil
+				}
+			}
+			fallthrough
+		case real:
+			if strings.TrimLeft(txt, "+-.0123456789Ee") == "" {
+				if f, err := strconv.ParseFloat(txt, 64); err == nil {
+					ctx.ResultFloat(f)
+					return nil
+				}
+			}
+			fallthrough
+		default:
+		}
+		ctx.ResultText(txt)
+	}
+	return nil
+}

ext/csv/csv_test.go

@@ -0,0 +1,209 @@
+package csv_test
+
+import (
+	"fmt"
+	"log"
+	"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"
+)
+
+func Example() {
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	err = csv.Register(db)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = db.Exec(`
+		CREATE VIRTUAL TABLE eurofxref USING csv(
+			filename = 'testdata/eurofxref.csv',
+			header   = YES,
+			columns  = 42,
+		)`)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT USD FROM eurofxref WHERE Date = '2022-02-22'`)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer stmt.Close()
+
+	if stmt.Step() {
+		fmt.Printf("On Twosday, 1€ = $%g", stmt.ColumnFloat(0))
+	}
+	if err := stmt.Reset(); err != nil {
+		log.Fatal(err)
+	}
+
+	err = db.Exec(`DROP TABLE eurofxref`)
+	if err != nil {
+		log.Fatal(err)
+	}
+	// Output:
+	// On Twosday, 1€ = $1.1342
+}
+
+func TestMain(m *testing.M) {
+	sqlite3.AutoExtension(csv.Register)
+	m.Run()
+}
+
+func TestRegister(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	const data = `
+# Comment
+"Rob"	"Pike"	rob
+"Ken"	Thompson	ken
+Robert	"Griesemer"	"gri"`
+	err = db.Exec(`
+		CREATE VIRTUAL TABLE temp.users USING csv(
+			data    = ` + sqlite3.Quote(data) + `,
+			schema  = 'CREATE TABLE x(first_name, last_name, username)',
+			comma   = '\t',
+			comment = '#'
+		)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT * FROM temp.users WHERE rowid = 1 ORDER BY username`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer stmt.Close()
+
+	if !stmt.Step() {
+		t.Fatal("no rows")
+	}
+	if got := stmt.ColumnText(0); got != "Rob" {
+		t.Errorf("got %q want Rob", got)
+	}
+	if stmt.Step() {
+		t.Fatal("more rows")
+	}
+
+	err = db.Exec(`ALTER TABLE temp.users RENAME TO csv`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`PRAGMA integrity_check`)
+	if err != nil {
+		t.Error(err)
+	}
+
+	err = db.Exec(`PRAGMA quick_check`)
+	if err != nil {
+		t.Error(err)
+	}
+
+	err = db.Exec(`DROP TABLE temp.csv`)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestAffinity(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	const data = "01\n0.10\ne"
+	err = db.Exec(`
+		CREATE VIRTUAL TABLE temp.nums USING csv(
+			data   = ` + sqlite3.Quote(data) + `,
+			schema = 'CREATE TABLE x(a numeric)'
+		)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT * FROM temp.nums`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer stmt.Close()
+
+	if stmt.Step() {
+		if got := stmt.ColumnText(0); got != "1" {
+			t.Errorf("got %q want 1", got)
+		}
+	}
+	if stmt.Step() {
+		if got := stmt.ColumnText(0); got != "0.1" {
+			t.Errorf("got %q want 0.1", got)
+		}
+	}
+	if stmt.Step() {
+		if got := stmt.ColumnText(0); got != "e" {
+			t.Errorf("got %q want e", got)
+		}
+	}
+}
+
+func TestRegister_errors(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Exec(`CREATE VIRTUAL TABLE temp.users USING csv()`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE temp.users USING csv(data='abc', data='abc')`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE temp.users USING csv(data='abc', xpto='abc')`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE temp.users USING csv(data='abc', comma='"')`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+
+	err = db.Exec(`CREATE VIRTUAL TABLE temp.users USING csv(data='abc', header=tru)`)
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+}

ext/csv/schema.go

@@ -0,0 +1,39 @@
+package csv
+
+import (
+	"strconv"
+	"strings"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+func getSchema(header bool, columns int, row []string) string {
+	var sep string
+	var str strings.Builder
+	str.WriteString("CREATE TABLE x(")
+
+	if 0 <= columns && columns < len(row) {
+		row = row[:columns]
+	}
+	for i, f := range row {
+		str.WriteString(sep)
+		if header && f != "" {
+			str.WriteString(sqlite3.QuoteIdentifier(f))
+		} else {
+			str.WriteString("c")
+			str.WriteString(strconv.Itoa(i + 1))
+		}
+		str.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")
+		sep = ","
+	}
+	str.WriteByte(')')
+
+	return str.String()
+}

ext/csv/schema_test.go

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

ext/csv/testdata/eurofxref.csv

@@ -0,0 +1,258 @@
+Date,USD,JPY,BGN,CYP,CZK,DKK,EEK,GBP,HUF,LTL,LVL,MTL,PLN,ROL,RON,SEK,SIT,SKK,CHF,ISK,NOK,HRK,RUB,TRL,TRY,AUD,BRL,CAD,CNY,HKD,IDR,ILS,INR,KRW,MXN,MYR,NZD,PHP,SGD,THB,ZAR,
+2022-12-30,1.0666,140.66,1.9558,N/A,24.116,7.4365,N/A,0.88693,400.87,N/A,N/A,N/A,4.6808,N/A,4.9495,11.1218,N/A,N/A,0.9847,151.5,10.5138,7.5365,N/A,N/A,19.9649,1.5693,5.6386,1.444,7.3582,8.3163,16519.82,3.7554,88.171,1344.09,20.856,4.6984,1.6798,59.32,1.43,36.835,18.0986,
+2022-12-29,1.0649,142.24,1.9558,N/A,24.191,7.4365,N/A,0.88549,399.6,N/A,N/A,N/A,4.6855,N/A,4.9493,11.158,N/A,N/A,0.984,152.5,10.55,7.5365,N/A,N/A,19.934,1.5859,5.5351,1.4475,7.4151,8.2994,16680.38,3.7575,88.2295,1350.18,20.651,4.7106,1.6887,59.367,1.436,36.877,18.1967,
+2022-12-28,1.064,142.21,1.9558,N/A,24.252,7.4365,N/A,0.88058,403.3,N/A,N/A,N/A,4.7008,N/A,4.946,11.1038,N/A,N/A,0.9863,151.9,10.4495,7.5365,N/A,N/A,19.9144,1.566,5.6109,1.4361,7.4224,8.2931,16765.93,3.7526,88.0943,1348.59,20.6856,4.7055,1.6772,59.613,1.4323,36.953,18.289,
+2022-12-27,1.0624,141.68,1.9558,N/A,24.26,7.4366,N/A,0.88333,401.65,N/A,N/A,N/A,4.6683,N/A,4.927,11.1285,N/A,N/A,0.9885,152.3,10.4895,7.5375,N/A,N/A,19.8799,1.577,5.6035,1.4384,7.3994,8.2874,16620.58,3.7278,88.0808,1349.85,20.5515,4.699,1.6916,59.356,1.43,36.775,18.3181,
+2022-12-23,1.0622,140.86,1.9558,N/A,24.247,7.4364,N/A,0.8803,400.68,N/A,N/A,N/A,4.6423,N/A,4.9056,11.1045,N/A,N/A,0.9867,152.3,10.4448,7.537,N/A,N/A,19.843,1.5857,5.4834,1.4433,7.4198,8.2878,16569.18,3.704,87.958,1359.5,20.7115,4.7002,1.6887,58.623,1.4337,36.842,18.1048,
+2022-12-22,1.0633,140.42,1.9558,N/A,24.215,7.4367,N/A,0.88243,402.13,N/A,N/A,N/A,4.6443,N/A,4.8993,11.05,N/A,N/A,0.9852,153.3,10.4123,7.538,N/A,N/A,19.8553,1.5804,5.5386,1.4484,7.4229,8.2883,16525.91,3.6942,88.0365,1361.75,20.8485,4.7051,1.6918,58.705,1.4356,36.849,18.2238,
+2022-12-21,1.0636,140.29,1.9558,N/A,24.218,7.438,N/A,0.87651,402.93,N/A,N/A,N/A,4.6665,N/A,4.8937,11.0623,N/A,N/A,0.9836,152.1,10.4309,7.5419,N/A,N/A,19.8541,1.5859,5.4913,1.4475,7.4219,8.2902,16573.77,3.6989,88.109,1367.63,20.9919,4.7197,1.685,58.556,1.4366,36.907,18.3529,
+2022-12-20,1.0599,140.58,1.9558,N/A,24.181,7.4388,N/A,0.8753,403.88,N/A,N/A,N/A,4.6757,N/A,4.9125,11.0615,N/A,N/A,0.9854,151.5,10.5098,7.5471,N/A,N/A,19.7744,1.5972,5.6234,1.4451,7.39,8.2488,16537.09,3.6759,87.6649,1363.73,20.9355,4.6991,1.6816,58.549,1.4347,36.853,18.4239,
+2022-12-19,1.0598,144.65,1.9558,N/A,24.233,7.4382,N/A,0.87118,403.18,N/A,N/A,N/A,4.6853,N/A,4.9107,11.0063,N/A,N/A,0.9884,151.9,10.5025,7.5395,N/A,N/A,19.7676,1.5794,5.6327,1.4472,7.3901,8.2428,16506.72,3.6551,87.5321,1377.17,20.9743,4.6912,1.6632,58.649,1.4378,36.923,18.3074,
+2022-12-16,1.0619,145.53,1.9558,N/A,24.262,7.4379,N/A,0.87233,407.1,N/A,N/A,N/A,4.6925,N/A,4.9213,11.0153,N/A,N/A,0.9879,150.1,10.4833,7.5385,N/A,N/A,19.8039,1.5866,5.6233,1.4506,7.4037,8.2632,16575.47,3.6689,87.824,1389.7,21.0634,4.6984,1.6687,58.967,1.4413,37.145,18.6708,
+2022-12-15,1.0621,145.07,1.9558,N/A,24.27,7.4387,N/A,0.86194,406.4,N/A,N/A,N/A,4.689,N/A,4.922,10.898,N/A,N/A,0.9862,150.9,10.4013,7.5395,N/A,N/A,19.806,1.5695,5.6247,1.4443,7.4007,8.2551,16591.4,3.6388,87.9355,1393.97,20.9431,4.6918,1.6628,59.297,1.4406,37.12,18.3599,
+2022-12-14,1.0649,143.68,1.9558,N/A,24.276,7.4392,N/A,0.86118,406.63,N/A,N/A,N/A,4.681,N/A,4.9248,10.8638,N/A,N/A,0.9865,150.9,10.362,7.538,N/A,N/A,19.8579,1.551,5.6842,1.4441,7.4009,8.2751,16599.51,3.6327,87.8435,1379.99,20.8635,4.6765,1.6508,59.326,1.4349,36.851,18.2563,
+2022-12-13,1.0545,144.85,1.9558,N/A,24.287,7.4391,N/A,0.85753,409.65,N/A,N/A,N/A,4.6938,N/A,4.9298,10.8965,N/A,N/A,0.9869,151.1,10.4679,7.5495,N/A,N/A,19.6649,1.5553,5.5784,1.4341,7.3637,8.2033,16521.81,3.6266,87.2965,1378.75,20.9435,4.6704,1.6464,58.852,1.4288,36.707,18.6855,
+2022-12-12,1.0562,144.86,1.9558,N/A,24.307,7.4379,N/A,0.86006,416.78,N/A,N/A,N/A,4.6923,N/A,4.9318,10.9075,N/A,N/A,0.9855,150.7,10.5548,7.554,N/A,N/A,19.6913,1.5625,5.556,1.4428,7.367,8.2103,16524.63,3.6232,87.253,1377.93,20.9047,4.6652,1.6523,58.788,1.4284,36.708,18.4697,
+2022-12-09,1.0559,143.3,1.9558,N/A,24.293,7.4379,N/A,0.8595,417.53,N/A,N/A,N/A,4.6869,N/A,4.9224,10.9188,N/A,N/A,0.9856,149.5,10.5345,7.555,N/A,N/A,19.6872,1.5553,5.5457,1.438,7.3475,8.2169,16453.46,3.6128,86.9535,1373.94,20.849,4.6512,1.6482,58.47,1.426,36.656,18.2358,
+2022-12-08,1.0519,143.75,1.9558,N/A,24.324,7.4382,N/A,0.86258,417.66,N/A,N/A,N/A,4.6853,N/A,4.9131,10.906,N/A,N/A,0.9889,149.5,10.488,7.5553,N/A,N/A,19.6114,1.559,5.488,1.4307,7.3324,8.1889,16423.92,3.6206,86.6755,1387.06,20.6989,4.6257,1.6547,58.233,1.4256,36.559,18.0225,
+2022-12-07,1.0529,144.44,1.9558,N/A,24.322,7.4382,N/A,0.86408,410.63,N/A,N/A,N/A,4.7003,N/A,4.918,10.919,N/A,N/A,0.9893,148.7,10.5255,7.5525,N/A,N/A,19.6256,1.5728,5.5023,1.4387,7.3476,8.1997,16465.17,3.626,86.692,1390.87,20.7534,4.6301,1.6573,58.432,1.4286,36.904,18.1353,
+2022-12-06,1.0516,143.33,1.9558,N/A,24.316,7.438,N/A,0.8617,415.08,N/A,N/A,N/A,4.6975,N/A,4.913,10.889,N/A,N/A,0.9872,148.9,10.4408,7.5563,N/A,N/A,19.601,1.5625,5.5113,1.4326,7.3494,8.1813,16441.49,3.5831,86.6485,1386.39,20.6884,4.6223,1.6583,58.782,1.4263,36.827,18.2068,
+2022-12-05,1.0587,143.07,1.9558,N/A,24.351,7.4369,N/A,0.86085,412.13,N/A,N/A,N/A,4.695,N/A,4.9215,10.8931,N/A,N/A,0.9893,148.9,10.3366,7.551,N/A,N/A,19.7326,1.5542,5.5491,1.4198,7.3573,8.2236,16332.36,3.5856,86.5249,1370.87,20.7295,4.6255,1.6498,59.245,1.4271,36.732,18.2038,
+2022-12-02,1.0538,141.32,1.9558,N/A,24.377,7.4373,N/A,0.85855,410,N/A,N/A,N/A,4.684,N/A,4.9298,10.902,N/A,N/A,0.9834,148.7,10.2615,7.5503,N/A,N/A,19.6392,1.5457,5.4657,1.416,7.3971,8.2035,16179.78,3.5769,85.6435,1366.67,20.187,4.6241,1.6453,58.734,1.4227,36.614,18.2749,
+2022-12-01,1.0454,142.48,1.9558,N/A,24.361,7.4373,N/A,0.85715,413.5,N/A,N/A,N/A,4.6998,N/A,4.9303,10.8984,N/A,N/A,0.9868,148.7,10.2495,7.55,N/A,N/A,19.4778,1.5377,5.4508,1.4059,7.3965,8.1371,16160.84,3.5642,84.933,1363.81,20.1472,4.605,1.6446,58.793,1.4195,36.526,18.5393,
+2022-11-30,1.0376,144.28,1.9558,N/A,24.338,7.4366,N/A,0.86488,408.4,N/A,N/A,N/A,4.6635,N/A,4.9245,10.9345,N/A,N/A,0.9854,147.1,10.2648,7.549,N/A,N/A,19.3333,1.5425,5.5063,1.4021,7.3437,8.0944,16271.81,3.5691,84.4215,1365.14,20.0111,4.6147,1.6634,58.697,1.418,36.588,17.5768,
+2022-11-29,1.0366,143.36,1.9558,N/A,24.334,7.4367,N/A,0.86218,406.5,N/A,N/A,N/A,4.673,N/A,4.9193,10.901,N/A,N/A,0.9862,147.1,10.3313,7.55,N/A,N/A,19.3181,1.5414,5.5126,1.4005,7.4289,8.0965,16301.58,3.5581,84.6548,1375.7,19.8075,4.6735,1.6639,58.64,1.4237,36.706,17.6027,
+2022-11-28,1.0463,144.9,1.9558,N/A,24.348,7.4367,N/A,0.86606,408.87,N/A,N/A,N/A,4.6938,N/A,4.9246,10.8973,N/A,N/A,0.9872,146.7,10.364,7.5488,N/A,N/A,19.4844,1.5632,5.6354,1.4062,7.5326,8.1782,16440.45,3.6002,85.437,1396.56,20.22,4.6874,1.6827,59.21,1.4375,37.285,17.9376,
+2022-11-25,1.0375,144.62,1.9558,N/A,24.367,7.4365,N/A,0.85885,411.33,N/A,N/A,N/A,4.6875,N/A,4.9255,10.8183,N/A,N/A,0.9836,146.5,10.2985,7.5473,N/A,N/A,19.3333,1.5404,5.5476,1.3864,7.4425,8.1084,16282.44,3.5551,84.7145,1383.2,20.1069,4.648,1.6651,58.795,1.4277,37.153,17.7677,
+2022-11-24,1.0413,143.9,1.9558,N/A,24.392,7.4369,N/A,0.85933,413.33,N/A,N/A,N/A,4.6958,N/A,4.9205,10.8573,N/A,N/A,0.9818,146.5,10.3435,7.547,N/A,N/A,19.3969,1.5414,5.5504,1.3894,7.4442,8.1324,16295.35,3.5607,85.0295,1382.28,20.1501,4.6806,1.6598,58.992,1.4319,37.258,17.7246,
+2022-11-23,1.0325,145.75,1.9558,N/A,24.356,7.437,N/A,0.86369,405.75,N/A,N/A,N/A,4.7033,N/A,4.937,10.8933,N/A,N/A,0.9795,146.7,10.3659,7.5435,N/A,N/A,19.2316,1.5522,5.565,1.3856,7.3982,8.0708,16189.81,3.5681,84.466,1397.42,20.001,4.7237,1.6718,58.914,1.4295,37.423,17.7103,
+2022-11-22,1.0274,145.2,1.9558,N/A,24.351,7.4377,N/A,0.86358,408.23,N/A,N/A,N/A,4.7125,N/A,4.9269,10.9653,N/A,N/A,0.9791,145.7,10.4445,7.5438,N/A,N/A,19.1221,1.5473,5.4578,1.3765,7.3344,8.0313,16106.79,3.5615,83.8768,1392.68,20.0951,4.7055,1.6707,58.942,1.4167,37.11,17.7568,
+2022-11-21,1.0246,145.33,1.9558,N/A,24.356,7.4377,N/A,0.86793,409.43,N/A,N/A,N/A,4.7075,N/A,4.9413,10.9873,N/A,N/A,0.9817,147.9,10.4898,7.5425,N/A,N/A,19.0822,1.5471,5.4401,1.377,7.3419,7.9989,16116.76,3.5515,83.7375,1395,19.9357,4.6927,1.6766,58.822,1.4162,37.121,17.7858,
+2022-11-18,1.0366,145.12,1.9558,N/A,24.351,7.4385,N/A,0.87063,407.41,N/A,N/A,N/A,4.7033,N/A,4.9413,10.9805,N/A,N/A,0.9881,148.9,10.486,7.5415,N/A,N/A,19.3009,1.5433,5.547,1.3841,7.379,8.1092,16224.36,3.591,84.6875,1389.02,20.162,4.7202,1.6757,59.41,1.4229,37.069,17.908,
+2022-11-17,1.0319,144.8,1.9558,N/A,24.399,7.4383,N/A,0.87475,415.6,N/A,N/A,N/A,4.7153,N/A,4.9254,10.9871,N/A,N/A,0.9818,148.9,10.498,7.541,N/A,N/A,19.2124,1.5526,5.6535,1.382,7.3859,8.077,16224.01,3.5796,84.394,1394.06,20.062,4.7122,1.6986,59.293,1.4221,37.123,18.0961,
+2022-11-16,1.0412,145.29,1.9558,N/A,24.355,7.4386,N/A,0.87483,408.18,N/A,N/A,N/A,4.7065,N/A,4.9206,10.8754,N/A,N/A,0.9795,148.9,10.3675,7.5443,N/A,N/A,19.3783,1.54,5.5438,1.3801,7.372,8.1444,16248.37,3.5684,84.5905,1378.1,20.1227,4.7323,1.6897,59.678,1.425,37.103,18.0195,
+2022-11-15,1.0404,144.84,1.9558,N/A,24.326,7.4388,N/A,0.87455,405.45,N/A,N/A,N/A,4.7073,N/A,4.9116,10.8081,N/A,N/A,0.979,149.9,10.357,7.5459,N/A,N/A,19.3608,1.5415,5.548,1.3816,7.3299,8.143,16164.78,3.5694,84.1304,1365.61,20.0795,4.7208,1.6897,59.532,1.4238,36.939,17.8822,
+2022-11-14,1.0319,144.86,1.9558,N/A,24.289,7.4382,N/A,0.87513,407.28,N/A,N/A,N/A,4.6898,N/A,4.9043,10.7713,N/A,N/A,0.9751,150.3,10.3143,7.5465,N/A,N/A,19.1923,1.5427,5.4605,1.3706,7.2906,8.0852,16052.12,3.541,83.7779,1369.32,20.0985,4.7429,1.6957,59.04,1.4177,36.978,17.8393,
+2022-11-11,1.0308,143.89,1.9558,N/A,24.278,7.4384,N/A,0.87538,402.08,N/A,N/A,N/A,4.6765,N/A,4.894,10.7241,N/A,N/A,0.9844,148.7,10.2635,7.5445,N/A,N/A,19.0987,1.5459,5.5147,1.3698,7.3267,8.0758,15979.45,3.5255,83.2253,1359.2,20.0239,4.77,1.702,59.106,1.4199,37.088,17.7944,
+2022-11-10,0.9954,145.47,1.9558,N/A,24.361,7.4381,N/A,0.87298,400.95,N/A,N/A,N/A,4.706,N/A,4.8913,10.8743,N/A,N/A,0.9834,147.5,10.3615,7.5427,N/A,N/A,18.51,1.5525,5.286,1.3467,7.2184,7.8128,15615.6,3.5453,81.3058,1373.96,19.4562,4.6789,1.6984,57.793,1.3963,36.7,17.6882,
+2022-11-09,1.0039,146.82,1.9558,N/A,24.337,7.4382,N/A,0.87774,403.53,N/A,N/A,N/A,4.701,N/A,4.9045,10.845,N/A,N/A,0.988,146.7,10.322,7.5425,N/A,N/A,18.6728,1.5538,5.1947,1.3501,7.2813,7.8801,15717.07,3.5621,81.6575,1369.73,19.6554,4.7098,1.7033,58.236,1.4061,36.999,17.877,
+2022-11-08,0.9996,146.25,1.9558,N/A,24.326,7.4378,N/A,0.87378,400.75,N/A,N/A,N/A,4.6918,N/A,4.8978,10.8373,N/A,N/A,0.9911,146.3,10.2795,7.539,N/A,N/A,18.5991,1.5435,5.203,1.3489,7.2495,7.8468,15652.76,3.5436,81.518,1377.94,19.4495,4.7346,1.686,58.187,1.4022,37.22,17.8397,
+2022-11-07,0.9993,146.18,1.9558,N/A,24.301,7.4393,N/A,0.87135,401.03,N/A,N/A,N/A,4.6865,N/A,4.8855,10.832,N/A,N/A,0.9874,145.9,10.2555,7.5375,N/A,N/A,18.5875,1.5428,5.07,1.3464,7.2189,7.8444,15648.95,3.5402,81.8407,1391.25,19.4395,4.7362,1.6834,58.361,1.4022,37.284,17.7583,
+2022-11-04,0.9872,145.19,1.9558,N/A,24.422,7.4419,N/A,0.87478,401.15,N/A,N/A,N/A,4.6825,N/A,4.8893,10.8538,N/A,N/A,0.9863,145.5,10.2019,7.5353,N/A,N/A,18.3845,1.5311,4.9682,1.3351,7.0894,7.7493,15491.81,3.5065,81.02,1397.7,19.2611,4.6872,1.6769,57.672,1.3891,36.906,17.7983,
+2022-11-03,0.9753,144.58,1.9558,N/A,24.539,7.4433,N/A,0.87228,407.87,N/A,N/A,N/A,4.709,N/A,4.9013,10.932,N/A,N/A,0.9889,144.9,10.3543,7.5375,N/A,N/A,18.1602,1.5517,5.0262,1.3452,7.1367,7.656,15400.2,3.4847,80.8845,1391.75,19.2363,4.6271,1.6957,57.463,1.3878,37.091,18.0173,
+2022-11-02,0.9908,145.75,1.9558,N/A,24.506,7.4431,N/A,0.861,407,N/A,N/A,N/A,4.7035,N/A,4.912,10.9065,N/A,N/A,0.9861,143.7,10.2388,7.5335,N/A,N/A,18.4488,1.5426,5.0964,1.347,7.2156,7.7774,15492.57,3.4987,81.992,1402.01,19.4921,4.6944,1.6844,57.841,1.3983,37.314,17.9608,
+2022-11-01,0.9947,146.35,1.9558,N/A,24.484,7.4438,N/A,0.86058,406.9,N/A,N/A,N/A,4.7053,N/A,4.9138,10.874,N/A,N/A,0.9878,143.3,10.1835,7.5342,N/A,N/A,18.5216,1.5409,5.1337,1.3469,7.2165,7.8079,15534.6,3.4922,82.084,1404.63,19.5984,4.7119,1.6876,57.786,1.4017,37.45,17.9802,
+2022-10-31,0.9914,147.4,1.9558,N/A,24.488,7.4444,N/A,0.86115,409.65,N/A,N/A,N/A,4.7085,N/A,4.9143,10.901,N/A,N/A,0.9925,143.3,10.3028,7.531,N/A,N/A,18.4562,1.5529,5.2694,1.3553,7.238,7.7822,15489.55,3.4933,82.1035,1416.12,19.7122,4.6873,1.7099,57.8,1.4038,37.748,18.1736,
+2022-10-28,0.9951,146.79,1.9558,N/A,24.465,7.4423,N/A,0.8612,411.7,N/A,N/A,N/A,4.7275,N/A,4.9189,10.9403,N/A,N/A,0.992,143.3,10.2695,7.532,N/A,N/A,18.5219,1.5511,5.327,1.3542,7.2159,7.8107,15481.88,3.5215,82.0565,1417.7,19.7718,4.6994,1.7151,57.739,1.4055,37.724,18.053,
+2022-10-27,1.0037,147.37,1.9558,N/A,24.53,7.4387,N/A,0.86745,412.15,N/A,N/A,N/A,4.7585,N/A,4.8893,10.9583,N/A,N/A,0.9949,143.1,10.342,7.533,N/A,N/A,18.681,1.561,5.3889,1.3672,7.2552,7.8782,15629.06,3.5376,82.656,1428.57,20.015,4.7324,1.7316,58.441,1.4154,37.975,18.1521,
+2022-10-26,1.0023,147.32,1.9558,N/A,24.535,7.4381,N/A,0.86603,408.09,N/A,N/A,N/A,4.7548,N/A,4.8806,10.953,N/A,N/A,0.9917,143.5,10.3408,7.532,N/A,N/A,18.6461,1.5466,5.2944,1.3568,7.1948,7.8678,15589.27,3.5145,82.206,1422.11,19.8501,4.7262,1.7249,58.493,1.4104,37.862,18.0212,
+2022-10-25,0.9861,146.84,1.9558,N/A,24.472,7.4387,N/A,0.87143,413.7,N/A,N/A,N/A,4.777,N/A,4.9036,10.9728,N/A,N/A,0.9888,142.9,10.391,7.5315,N/A,N/A,18.3508,1.5599,5.2254,1.3537,7.2072,7.7407,15407.12,3.506,81.653,1417.5,19.6353,4.6697,1.7321,57.988,1.405,37.758,18.2211,
+2022-10-24,0.9851,146.76,1.9558,N/A,24.482,7.4385,N/A,0.8707,411.88,N/A,N/A,N/A,4.7908,N/A,4.9128,11.0795,N/A,N/A,0.9856,142.5,10.392,7.5337,N/A,N/A,18.3298,1.5631,5.1461,1.3502,7.1544,7.7329,15362.63,3.4997,81.5451,1418.4,19.6514,4.6674,1.7343,58.021,1.4008,37.6,18.0625,
+2022-10-21,0.973,147.59,1.9558,N/A,24.511,7.4382,N/A,0.87728,412.88,N/A,N/A,N/A,4.7885,N/A,4.9125,11.0868,N/A,N/A,0.9855,141.1,10.4315,7.5325,N/A,N/A,18.0988,1.5646,5.1117,1.3465,7.0504,7.6376,15199.12,3.4803,80.739,1404.32,19.5521,4.6101,1.7347,57.287,1.3917,37.349,18.0021,
+2022-10-20,0.9811,146.99,1.9558,N/A,24.525,7.4389,N/A,0.87258,411.2,N/A,N/A,N/A,4.7728,N/A,4.9203,10.982,N/A,N/A,0.9836,141.1,10.402,7.5353,N/A,N/A,18.2257,1.5554,5.1387,1.3461,7.0858,7.7008,15250.05,3.4754,81.1755,1400.3,19.7005,4.6396,1.7206,57.742,1.3959,37.36,17.9106,
+2022-10-19,0.9778,146.34,1.9558,N/A,24.563,7.439,N/A,0.86993,413.78,N/A,N/A,N/A,4.7878,N/A,4.9248,10.9448,N/A,N/A,0.981,141.1,10.3823,7.5325,N/A,N/A,18.1793,1.5568,5.1755,1.3479,7.0672,7.6757,15185.1,3.4628,81.1955,1398.35,19.6845,4.6152,1.7264,57.741,1.3931,37.469,17.8339,
+2022-10-18,0.9835,146.65,1.9558,N/A,24.593,7.4393,N/A,0.86928,413.08,N/A,N/A,N/A,4.804,N/A,4.9359,10.906,N/A,N/A,0.9792,141.5,10.3528,7.5298,N/A,N/A,18.2813,1.5557,5.1795,1.3495,7.0805,7.72,15214.98,3.464,80.9195,1400.92,19.664,4.6382,1.7251,57.897,1.3963,37.422,17.7904,
+2022-10-17,0.9739,145,1.9558,N/A,24.562,7.4379,N/A,0.8625,418.3,N/A,N/A,N/A,4.8143,N/A,4.937,10.9893,N/A,N/A,0.9762,140.9,10.342,7.5265,N/A,N/A,18.1043,1.5599,5.1497,1.3452,7.013,7.6448,15061.8,3.4486,80.128,1399.41,19.5,4.5934,1.7404,57.433,1.3896,37.169,17.6769,
+2022-10-14,0.9717,143.63,1.9558,N/A,24.587,7.4378,N/A,0.86823,418.24,N/A,N/A,N/A,4.8328,N/A,4.9335,11.0035,N/A,N/A,0.9757,140.5,10.3323,7.5266,N/A,N/A,18.0614,1.5493,5.1177,1.3426,6.9952,7.6278,15031.5,3.444,79.9695,1398.5,19.5032,4.5689,1.7302,57.375,1.3852,37.109,17.6932,
+2022-10-13,0.9739,142.94,1.9558,N/A,24.569,7.4385,N/A,0.86513,430.65,N/A,N/A,N/A,4.8303,N/A,4.9355,11.0098,N/A,N/A,0.9725,140.5,10.3525,7.531,N/A,N/A,18.1041,1.5495,5.1214,1.3443,6.9945,7.644,14952.86,3.4731,79.9981,1392.71,19.4442,4.5691,1.7314,57.352,1.3949,36.843,17.8173,
+2022-10-12,0.9706,142.34,1.9558,N/A,24.561,7.4399,N/A,0.8784,429.65,N/A,N/A,N/A,4.8495,N/A,4.94,11.02,N/A,N/A,0.9664,140.1,10.4145,7.529,N/A,N/A,18.0427,1.5525,5.1378,1.3395,6.9603,7.6192,14907.04,3.4623,79.8955,1384.66,19.4522,4.5448,1.7372,57.148,1.3941,36.902,17.6876,
+2022-10-11,0.9723,141.54,1.9558,N/A,24.535,7.439,N/A,0.87703,428.73,N/A,N/A,N/A,4.869,N/A,4.9394,11.0015,N/A,N/A,0.9675,140.7,10.4235,7.5293,N/A,N/A,18.0686,1.545,5.0456,1.3402,6.9669,7.6325,14930.83,3.4776,79.9555,1392.84,19.4115,4.5436,1.7323,57.243,1.3967,37.03,17.6153,
+2022-10-10,0.9697,141.16,1.9558,N/A,24.521,7.4384,N/A,0.8773,428.2,N/A,N/A,N/A,4.8655,N/A,4.94,10.9502,N/A,N/A,0.968,139.9,10.3378,7.528,N/A,N/A,18.0131,1.536,5.0328,1.3312,6.9344,7.612,14872.51,3.4463,79.9678,1384.26,19.3588,4.5091,1.7369,57.197,1.3939,36.81,17.5866,
+2022-10-07,0.9797,141.92,1.9558,N/A,24.517,7.4381,N/A,0.87383,423.85,N/A,N/A,N/A,4.8595,N/A,4.9415,10.8555,N/A,N/A,0.97,140.7,10.4498,7.527,N/A,N/A,18.209,1.5266,5.1075,1.3437,6.9715,7.6906,14933.14,3.4477,80.546,1381.42,19.643,4.5556,1.7328,57.747,1.3996,36.602,17.6222,
+2022-10-06,0.986,142.68,1.9558,N/A,24.479,7.439,N/A,0.87583,422.59,N/A,N/A,N/A,4.8505,N/A,4.9364,10.8728,N/A,N/A,0.9709,139.9,10.4278,7.5288,N/A,N/A,18.3191,1.5263,5.1185,1.3475,7.0164,7.74,15021.24,3.4846,81.0615,1388.39,19.817,4.5726,1.728,57.949,1.4057,36.827,17.5769,
+2022-10-05,0.9915,143.18,1.9558,N/A,24.524,7.4388,N/A,0.8734,423.6,N/A,N/A,N/A,4.791,N/A,4.9385,10.8376,N/A,N/A,0.9756,141.3,10.4858,7.5255,N/A,N/A,18.4201,1.538,5.1575,1.3493,7.0555,7.7831,15061.81,3.503,80.909,1406.71,19.8625,4.5911,1.7419,58.212,1.4124,37.102,17.6228,
+2022-10-04,0.9891,143.3,1.9558,N/A,24.544,7.4374,N/A,0.87273,417.68,N/A,N/A,N/A,4.8193,N/A,4.9418,10.8166,N/A,N/A,0.9767,141.9,10.4915,7.523,N/A,N/A,18.3374,1.5318,5.0589,1.3503,7.0384,7.7644,15080.18,3.4885,80.6995,1412.2,19.777,4.5939,1.7368,58.104,1.4148,37.16,17.5437,
+2022-10-03,0.9764,141.49,1.9558,N/A,24.527,7.4366,N/A,0.8707,424.86,N/A,N/A,N/A,4.832,N/A,4.9479,10.8743,N/A,N/A,0.9658,141.7,10.5655,7.5275,N/A,N/A,18.124,1.5128,5.178,1.3412,6.9481,7.6647,14969.79,3.498,79.898,1408.25,19.604,4.5383,1.7263,57.599,1.4015,37.181,17.5871,
+2022-09-30,0.9748,141.01,1.9558,N/A,24.549,7.4365,N/A,0.883,422.18,N/A,N/A,N/A,4.8483,N/A,4.949,10.8993,N/A,N/A,0.9561,140.9,10.5838,7.524,N/A,N/A,18.0841,1.5076,5.2584,1.3401,6.9368,7.6521,14863.26,3.4759,79.425,1400.69,19.6393,4.5201,1.7177,57.276,1.4001,36.823,17.5353,
+2022-09-29,0.9706,140.46,1.9558,N/A,24.687,7.4365,N/A,0.89485,421.93,N/A,N/A,N/A,4.857,N/A,4.9481,10.958,N/A,N/A,0.9538,140.1,10.4518,7.528,N/A,N/A,18,1.4982,5.2521,1.3294,6.9223,7.6192,14735.97,3.4422,79.314,1388.34,19.5779,4.4992,1.704,56.86,1.3961,36.946,17.4466,
+2022-09-28,0.9565,138.39,1.9558,N/A,24.65,7.4368,N/A,0.90268,411.72,N/A,N/A,N/A,4.8043,N/A,4.9485,10.9194,N/A,N/A,0.9437,139.7,10.4576,7.5313,N/A,N/A,17.7311,1.4924,5.1728,1.3157,6.9199,7.5084,14622.96,3.3931,78.2655,1378.84,19.5294,4.4281,1.6998,56.528,1.3846,36.687,17.2916,
+2022-09-27,0.9644,139.28,1.9558,N/A,24.661,7.4366,N/A,0.89275,406.65,N/A,N/A,N/A,4.764,N/A,4.9444,10.8533,N/A,N/A,0.9503,139.3,10.3473,7.528,N/A,N/A,17.824,1.4859,5.1235,1.3196,6.9156,7.5704,14604.52,3.3714,78.574,1370.06,19.5832,4.4466,1.6921,56.933,1.3838,36.565,17.2361,
+2022-09-26,0.9646,139.07,1.9558,N/A,24.64,7.4365,N/A,0.89404,408.83,N/A,N/A,N/A,4.7608,N/A,4.9418,10.9275,N/A,N/A,0.9555,138.9,10.3585,7.5278,N/A,N/A,17.8001,1.4858,5.1504,1.3195,6.9075,7.572,14620.74,3.4069,78.704,1379.4,19.6066,4.4401,1.6886,56.908,1.3842,36.496,17.4247,
+2022-09-23,0.9754,139.43,1.9558,N/A,24.658,7.4365,N/A,0.88201,406.3,N/A,N/A,N/A,4.7543,N/A,4.9433,10.9328,N/A,N/A,0.9565,139.9,10.2335,7.5228,N/A,N/A,17.9515,1.4828,5.0456,1.3177,6.9442,7.6567,14697.3,3.4152,79.0705,1381.97,19.5708,4.4659,1.6846,57.217,1.3897,36.636,17.3853,
+2022-09-22,0.9884,139.18,1.9558,N/A,24.657,7.4365,N/A,0.87256,405.25,N/A,N/A,N/A,4.7592,N/A,4.9411,10.8724,N/A,N/A,0.9684,139.9,10.235,7.5235,N/A,N/A,18.1559,1.484,5.0677,1.3278,6.9804,7.7583,14824.28,3.4216,79.897,1384.79,19.6129,4.514,1.6832,57.721,1.3998,36.803,17.3514,
+2022-09-21,0.9906,142.66,1.9558,N/A,24.637,7.4364,N/A,0.87335,405.1,N/A,N/A,N/A,4.7505,N/A,4.9443,10.9214,N/A,N/A,0.9549,140.3,10.2858,7.5205,N/A,N/A,18.149,1.4851,5.0924,1.3262,6.9821,7.7761,14866.28,3.4298,79.1555,1381.38,19.7847,4.5097,1.6844,57.285,1.4006,36.786,17.4879,
+2022-09-20,0.9986,143.34,1.9558,N/A,24.556,7.4368,N/A,0.87395,398.58,N/A,N/A,N/A,4.7208,N/A,4.934,10.8338,N/A,N/A,0.9644,140.9,10.273,7.5198,N/A,N/A,18.2833,1.4893,5.2139,1.3268,7.003,7.8382,14997.82,3.4406,79.6095,1390.71,19.9667,4.5516,1.6908,57.497,1.4074,36.968,17.7261,
+2022-09-19,0.999,143.42,1.9558,N/A,24.494,7.4373,N/A,0.87785,400.85,N/A,N/A,N/A,4.7058,N/A,4.93,10.7993,N/A,N/A,0.9658,139.9,10.2826,7.5215,N/A,N/A,18.2738,1.495,5.2886,1.3294,7.0066,7.8416,14975.43,3.446,79.653,1391.82,20.113,4.5455,1.6807,57.347,1.4082,36.983,17.7267,
+2022-09-16,0.9954,142.53,1.9558,N/A,24.497,7.4366,N/A,0.874,403.98,N/A,N/A,N/A,4.7143,N/A,4.9238,10.7541,N/A,N/A,0.9579,138.3,10.1985,7.5235,N/A,N/A,18.1923,1.4894,5.2279,1.3226,6.9787,7.8133,14904.67,3.4267,79.3605,1383.58,20.0028,4.5141,1.6717,57.111,1.4025,36.8,17.6004,
+2022-09-15,0.9992,143.43,1.9558,N/A,24.518,7.4366,N/A,0.86934,407.15,N/A,N/A,N/A,4.7273,N/A,4.9238,10.69,N/A,N/A,0.9572,138.7,10.1203,7.5258,N/A,N/A,18.2477,1.4853,5.1837,1.3172,6.9852,7.8423,14925.35,3.4384,79.7119,1397.18,20.0021,4.5314,1.6689,57.258,1.4062,36.816,17.5283,
+2022-09-14,0.999,143.08,1.9558,N/A,24.527,7.4366,N/A,0.86498,402.9,N/A,N/A,N/A,4.7163,N/A,4.9297,10.675,N/A,N/A,0.9612,139.7,10.1125,7.5195,N/A,N/A,18.2397,1.4873,5.1827,1.3177,6.955,7.8405,14903.93,3.4339,79.422,1391.97,20.028,4.5225,1.6675,57.054,1.4039,36.608,17.4342,
+2022-09-13,1.0175,144.5,1.9558,N/A,24.551,7.4366,N/A,0.86793,396.83,N/A,N/A,N/A,4.705,N/A,4.921,10.6108,N/A,N/A,0.9669,140.1,9.9988,7.5255,N/A,N/A,18.564,1.4736,5.1764,1.32,7.0467,7.9855,15099.17,3.4125,80.5453,1397.3,20.1615,4.5869,1.6555,57.665,1.4186,36.859,17.3112,
+2022-09-12,1.0155,144.49,1.9558,N/A,24.546,7.4365,N/A,0.86778,395.73,N/A,N/A,N/A,4.6965,N/A,4.9135,10.6368,N/A,N/A,0.9667,140.9,9.9718,7.5195,N/A,N/A,18.5232,1.4749,5.1933,1.3194,7.0348,7.9709,15083.83,3.4346,80.692,1397.58,20.1025,4.5733,1.6499,57.701,1.4168,36.873,17.322,
+2022-09-09,1.0049,143.3,1.9558,N/A,24.536,7.4365,N/A,0.8686,396.3,N/A,N/A,N/A,4.721,N/A,4.9019,10.6643,N/A,N/A,0.9657,140.9,9.9836,7.5245,N/A,N/A,18.3282,1.4704,5.2087,1.307,6.9543,7.8871,14905.33,3.4416,79.9685,1384.64,19.991,4.52,1.6463,57.098,1.4063,36.508,17.3753,
+2022-09-08,1.0009,143.65,1.9558,N/A,24.543,7.4365,N/A,0.86656,395.48,N/A,N/A,N/A,4.7155,N/A,4.8756,10.7075,N/A,N/A,0.9739,140.3,10.0615,7.515,N/A,N/A,18.2546,1.4824,5.2042,1.3134,6.9564,7.8568,14891.86,3.429,79.7375,1381.7,20.013,4.5051,1.6491,57.031,1.4054,36.418,17.3797,
+2022-09-07,0.9885,143.2,1.9558,N/A,24.631,7.4365,N/A,0.8651,401.83,N/A,N/A,N/A,4.729,N/A,4.8585,10.6888,N/A,N/A,0.975,141.3,9.9483,7.5143,N/A,N/A,18.0262,1.4748,5.1881,1.3037,6.8968,7.7596,14779.47,3.4053,79.028,1374.44,19.9225,4.4497,1.6459,56.532,1.3931,36.322,17.2582,
+2022-09-06,0.9928,140.91,1.9558,N/A,24.55,7.4365,N/A,0.85743,402.65,N/A,N/A,N/A,4.7068,N/A,4.8424,10.6825,N/A,N/A,0.9745,141.9,9.8945,7.5133,N/A,N/A,18.0938,1.4651,5.13,1.3029,6.9091,7.7932,14783.94,3.39,79.2305,1366.65,19.8545,4.4676,1.6313,56.655,1.3947,36.242,17.0805,
+2022-09-05,0.992,139.47,1.9558,N/A,24.622,7.4364,N/A,0.86358,403.9,N/A,N/A,N/A,4.736,N/A,4.8198,10.729,N/A,N/A,0.9747,142.7,9.9188,7.5173,N/A,N/A,18.0792,1.4616,5.1407,1.3043,6.8768,7.7867,14782.83,3.3826,79.2332,1359.98,19.8192,4.4563,1.6289,56.477,1.3932,36.263,17.088,
+2022-09-02,0.9993,140.36,1.9558,N/A,24.481,7.437,N/A,0.86478,398.38,N/A,N/A,N/A,4.7063,N/A,4.8335,10.7498,N/A,N/A,0.9839,141.5,10.0035,7.5225,N/A,N/A,18.2072,1.4671,5.2153,1.3131,6.9031,7.8439,14895.92,3.396,79.8096,1360.84,20.1024,4.4809,1.6394,56.854,1.4013,36.624,17.2791,
+2022-09-01,1.0004,139.34,1.9558,N/A,24.488,7.4372,N/A,0.86473,399.58,N/A,N/A,N/A,4.7128,N/A,4.8447,10.7415,N/A,N/A,0.9802,141.7,10.013,7.521,N/A,N/A,18.2149,1.4651,5.2239,1.3169,6.9017,7.8511,14878,3.3644,79.6195,1353.69,20.1954,4.4828,1.6389,56.609,1.4002,36.71,17.1524,
+2022-08-31,1,138.72,1.9558,N/A,24.55,7.4371,N/A,0.86035,402.8,N/A,N/A,N/A,4.7283,N/A,4.8595,10.6788,N/A,N/A,0.9796,141.7,9.9388,7.5148,N/A,N/A,18.1849,1.4591,5.1482,1.3111,6.8947,7.8488,14849.93,3.3399,79.5465,1342.79,20.2044,4.4755,1.6322,56.153,1.3969,36.45,17.0667,
+2022-08-30,1.0034,138.71,1.9558,N/A,24.577,7.4376,N/A,0.85645,406.38,N/A,N/A,N/A,4.7323,N/A,4.8657,10.65,N/A,N/A,0.9741,142.1,9.7553,7.5103,N/A,N/A,18.239,1.4472,5.0286,1.3047,6.9233,7.8751,14875,3.3168,79.8025,1350.92,20.0077,4.4907,1.6245,56.393,1.3997,36.494,16.8567,
+2022-08-29,0.9986,138.49,1.9558,N/A,24.592,7.4379,N/A,0.8542,409.9,N/A,N/A,N/A,4.745,N/A,4.8699,10.628,N/A,N/A,0.967,141.1,9.7675,7.5119,N/A,N/A,18.1605,1.4529,5.0663,1.3026,6.9044,7.8368,14871.09,3.3146,79.8295,1347.47,19.9876,4.4837,1.6305,56.187,1.395,36.399,16.8891,
+2022-08-26,1.0007,137.02,1.9558,N/A,24.635,7.4379,N/A,0.8459,410.48,N/A,N/A,N/A,4.7485,N/A,4.8729,10.5703,N/A,N/A,0.9642,140.3,9.667,7.5135,N/A,N/A,18.1923,1.4333,5.1069,1.2944,6.8671,7.8521,14825.57,3.2537,79.9025,1333.46,19.924,4.4706,1.6112,56.109,1.3906,36.035,16.7995,
+2022-08-25,0.997,136.07,1.9558,N/A,24.648,7.4374,N/A,0.84293,408.93,N/A,N/A,N/A,4.7578,N/A,4.8758,10.5525,N/A,N/A,0.9616,140.3,9.64,7.514,N/A,N/A,18.112,1.4306,5.0879,1.2881,6.8317,7.8234,14753.15,3.2791,79.6555,1331.98,19.8132,4.4586,1.6006,55.842,1.3857,35.732,16.7903,
+2022-08-24,0.9934,135.74,1.9558,N/A,24.629,7.4381,N/A,0.84283,410.93,N/A,N/A,N/A,4.7668,N/A,4.88,10.586,N/A,N/A,0.9576,139.5,9.636,7.5125,N/A,N/A,18.0362,1.4389,5.0606,1.2908,6.822,7.795,14757.6,3.2599,79.3006,1332.84,19.7781,4.4559,1.6065,55.7,1.3857,35.906,16.8976,
+2022-08-23,0.9927,136.34,1.9558,N/A,24.658,7.4374,N/A,0.84343,410.55,N/A,N/A,N/A,4.7788,N/A,4.8839,10.6063,N/A,N/A,0.9602,140.1,9.7438,7.5128,N/A,N/A,17.983,1.4437,5.0984,1.2928,6.7952,7.79,14743.28,3.2598,79.2805,1332.1,19.9152,4.4557,1.6071,55.661,1.386,35.856,16.9568,
+2022-08-22,1.0001,137.08,1.9558,N/A,24.651,7.437,N/A,0.84658,408,N/A,N/A,N/A,4.764,N/A,4.8853,10.65,N/A,N/A,0.958,140.9,9.7719,7.5113,N/A,N/A,18.1268,1.4478,5.1752,1.2989,6.8457,7.8468,14895.47,3.2778,79.8615,1344.21,20.1583,4.4854,1.6125,56.218,1.3958,36.099,17.0766,
+2022-08-19,1.0054,137.67,1.9558,N/A,24.625,7.4373,N/A,0.84938,407.35,N/A,N/A,N/A,4.751,N/A,4.8811,10.6095,N/A,N/A,0.9616,140.5,9.8418,7.5155,N/A,N/A,18.2028,1.4584,5.2334,1.3062,6.8531,7.8877,14951.91,3.2879,80.2988,1343.39,20.3273,4.5007,1.6203,56.325,1.3979,35.988,17.1007,
+2022-08-18,1.0178,137.17,1.9558,N/A,24.611,7.4389,N/A,0.84391,405.13,N/A,N/A,N/A,4.724,N/A,4.8808,10.5903,N/A,N/A,0.9683,140.5,9.8283,7.5215,N/A,N/A,18.4095,1.4617,5.2326,1.3118,6.906,7.9844,15092.62,3.2993,81.042,1344.81,20.313,4.5536,1.6145,56.776,1.4053,36.254,17.0004,
+2022-08-17,1.0164,137.36,1.9558,N/A,24.566,7.4377,N/A,0.84208,404.28,N/A,N/A,N/A,4.7078,N/A,4.8825,10.5617,N/A,N/A,0.9686,140.3,9.8428,7.5071,N/A,N/A,18.2568,1.4655,5.2838,1.3117,6.8917,7.9705,15015.81,3.311,80.7555,1337.02,20.3825,4.5413,1.6165,56.772,1.4051,36.052,16.9125,
+2022-08-16,1.0131,136.11,1.9558,N/A,24.54,7.4368,N/A,0.84218,406.2,N/A,N/A,N/A,4.7043,N/A,4.882,10.5365,N/A,N/A,0.9625,140.3,9.8428,7.51,N/A,N/A,18.1994,1.4463,5.1835,1.3076,6.8767,7.9449,14968.68,3.3087,80.3745,1329.66,20.1595,4.5245,1.6012,56.602,1.398,35.93,16.6556,
+2022-08-15,1.0195,135.61,1.9558,N/A,24.46,7.4373,N/A,0.84375,398.6,N/A,N/A,N/A,4.6858,N/A,4.8849,10.498,N/A,N/A,0.9631,140.3,9.871,7.5028,N/A,N/A,18.3143,1.4508,5.2268,1.3167,6.905,7.9899,15042.36,3.3294,81.061,1336.35,20.3914,4.5465,1.6002,57.122,1.4036,36.218,16.7375,
+2022-08-12,1.0285,137.47,1.9558,N/A,24.38,7.4395,N/A,0.84715,392.3,N/A,N/A,N/A,4.6773,N/A,4.8915,10.4515,N/A,N/A,0.9689,140.3,9.813,7.5138,N/A,N/A,18.4733,1.4496,5.3007,1.3148,6.9352,8.06,15104.2,3.345,81.9935,1342.59,20.4925,4.5709,1.5985,57.246,1.4106,36.393,16.7318,
+2022-08-11,1.0338,136.57,1.9558,N/A,24.346,7.4395,N/A,0.84575,394.18,N/A,N/A,N/A,4.6828,N/A,4.9055,10.36,N/A,N/A,0.9712,139.7,9.804,7.515,N/A,N/A,18.5674,1.4532,5.2447,1.3202,6.9668,8.1118,15215.93,3.3505,82.2845,1344.62,20.6398,4.5952,1.6045,57.225,1.4151,36.343,16.7083,
+2022-08-10,1.0252,138.16,1.9558,N/A,24.397,7.4397,N/A,0.84608,397.65,N/A,N/A,N/A,4.7063,N/A,4.9138,10.3773,N/A,N/A,0.9713,139.7,9.9118,7.5158,N/A,N/A,18.4099,1.4682,5.251,1.3207,6.9222,8.046,15218.87,3.3773,81.468,1344.16,20.713,4.5693,1.6211,57.061,1.4107,36.42,16.8788,
+2022-08-09,1.0234,138.26,1.9558,N/A,24.532,7.4407,N/A,0.8452,397.35,N/A,N/A,N/A,4.7085,N/A,4.9038,10.3875,N/A,N/A,0.9763,140.1,9.9365,7.514,N/A,N/A,18.3342,1.4687,5.2478,1.3163,6.9106,8.0334,15197.09,3.3865,81.406,1336.74,20.7145,4.5592,1.6304,56.939,1.411,36.264,17.05,
+2022-08-08,1.0199,137.62,1.9558,N/A,24.515,7.4405,N/A,0.84165,394.27,N/A,N/A,N/A,4.7043,N/A,4.9163,10.365,N/A,N/A,0.9763,140.1,9.9405,7.5123,N/A,N/A,18.3175,1.4607,5.238,1.3134,6.8931,8.0061,15147.65,3.3895,81.166,1329.93,20.681,4.5477,1.6202,56.554,1.4058,36.38,16.9694,
+2022-08-05,1.0233,136.22,1.9558,N/A,24.581,7.4415,N/A,0.84268,393.78,N/A,N/A,N/A,4.7085,N/A,4.9251,10.3573,N/A,N/A,0.9776,138.9,9.982,7.5148,N/A,N/A,18.3853,1.4713,5.3348,1.3185,6.9068,8.0328,15236.2,3.4033,81.0469,1324.53,20.8367,4.5598,1.6248,56.524,1.4077,36.373,17.0342,
+2022-08-04,1.0181,135.81,1.9558,N/A,24.659,7.4425,N/A,0.84231,395.98,N/A,N/A,N/A,4.7233,N/A,4.9261,10.374,N/A,N/A,0.9765,138.7,9.9065,7.515,N/A,N/A,18.2922,1.4607,5.3614,1.307,6.8769,7.9919,15200.94,3.4101,80.7715,1333.7,20.756,4.5387,1.6172,56.633,1.4037,36.606,17.0352,
+2022-08-03,1.0194,136.18,1.9558,N/A,24.65,7.4427,N/A,0.83629,395.03,N/A,N/A,N/A,4.691,N/A,4.9245,10.3913,N/A,N/A,0.9773,139.3,9.8743,7.5178,N/A,N/A,18.3112,1.4681,5.3547,1.3085,6.883,8.0022,15184.35,3.4362,80.6895,1336.03,21.0788,4.5435,1.6266,56.855,1.4069,36.963,17.1283,
+2022-08-02,1.0224,133.9,1.9558,N/A,24.644,7.4432,N/A,0.83665,396.82,N/A,N/A,N/A,4.7063,N/A,4.9298,10.3995,N/A,N/A,0.9744,139.3,9.9305,7.5195,N/A,N/A,18.3564,1.4745,5.3175,1.315,6.9117,8.0257,15204.85,3.4486,80.3243,1339.16,20.952,4.5531,1.6254,56.834,1.4103,36.914,16.982,
+2022-08-01,1.0233,135.38,1.9558,N/A,24.628,7.4457,N/A,0.837,401.35,N/A,N/A,N/A,4.734,N/A,4.9283,10.3668,N/A,N/A,0.9717,138.7,9.8638,7.521,N/A,N/A,18.3475,1.4535,5.2723,1.3076,6.9105,8.0329,15203.21,3.4546,80.9335,1333.3,20.7635,4.5568,1.616,56.734,1.4087,36.977,16.8613,
+2022-07-29,1.0198,136.42,1.9558,N/A,24.61,7.4438,N/A,0.8399,404.8,N/A,N/A,N/A,4.7375,N/A,4.9343,10.3875,N/A,N/A,0.9744,138.3,9.8773,7.518,N/A,N/A,18.2472,1.4646,5.2739,1.31,6.8705,8.0054,15155.56,3.4714,80.882,1329.4,20.6745,4.5386,1.6283,56.375,1.4088,36.978,16.8627,
+2022-07-28,1.0122,137.26,1.9558,N/A,24.609,7.4442,N/A,0.83586,407.3,N/A,N/A,N/A,4.7908,N/A,4.9342,10.449,N/A,N/A,0.9745,138.7,9.8983,7.52,N/A,N/A,18.1417,1.4535,5.33,1.2986,6.8325,7.9456,15107.59,3.4701,80.6535,1320.45,20.676,4.5071,1.6172,56.592,1.4009,37.097,17.0011,
+2022-07-27,1.0152,138.89,1.9558,N/A,24.575,7.4446,N/A,0.84138,404.67,N/A,N/A,N/A,4.7978,N/A,4.9334,10.4545,N/A,N/A,0.9768,139.1,9.9558,7.514,N/A,N/A,18.1859,1.462,5.4039,1.3049,6.8534,7.9692,15213.07,3.4855,81.135,1333.99,20.753,4.5263,1.6306,56.455,1.4088,37.4,17.1347,
+2022-07-26,1.0124,138.35,1.9558,N/A,24.607,7.4449,N/A,0.84558,400.99,N/A,N/A,N/A,4.742,N/A,4.9324,10.4445,N/A,N/A,0.9765,139.1,10.0105,7.5145,N/A,N/A,18.0705,1.4605,5.4437,1.3035,6.8451,7.9466,15185.27,3.4891,80.805,1326.65,20.7845,4.5113,1.6235,56.16,1.4066,37.18,17.087,
+2022-07-25,1.0236,139.84,1.9558,N/A,24.535,7.4449,N/A,0.84813,396.5,N/A,N/A,N/A,4.708,N/A,4.9339,10.3973,N/A,N/A,0.9869,139.5,10.0704,7.5195,N/A,N/A,18.2653,1.4707,5.5976,1.3168,6.9094,8.0345,15303.87,3.5201,81.6675,1341.25,20.9376,4.5586,1.6325,57.209,1.4176,37.525,17.1502,
+2022-07-22,1.019,139.51,1.9558,N/A,24.514,7.4443,N/A,0.85141,398.3,N/A,N/A,N/A,4.7508,N/A,4.9321,10.4328,N/A,N/A,0.9832,139.5,10.1498,7.5234,N/A,N/A,18.094,1.4677,5.5821,1.3105,6.8852,7.9985,15275.69,3.5083,81.384,1335.66,20.9595,4.5366,1.6265,57.24,1.4151,37.392,17.2009,
+2022-07-21,1.0199,141.46,1.9558,N/A,24.496,7.4446,N/A,0.85545,400.13,N/A,N/A,N/A,4.761,N/A,4.9391,10.426,N/A,N/A,0.9924,139.7,10.175,7.52,N/A,N/A,18.0327,1.4848,5.5777,1.3178,6.904,8.0056,15342.25,3.5203,81.451,1337.47,20.941,4.5457,1.6479,57.512,1.4218,37.66,17.5195,
+2022-07-20,1.0199,140.92,1.9558,N/A,24.493,7.4452,N/A,0.85178,399.5,N/A,N/A,N/A,4.782,N/A,4.9396,10.4606,N/A,N/A,0.9896,139.5,10.1323,7.5143,N/A,N/A,17.9444,1.4767,5.5427,1.3132,6.8892,8.0062,15275.82,3.5147,81.599,1337.61,20.8967,4.5406,1.6308,57.398,1.4204,37.405,17.3924,
+2022-07-19,1.0245,141.01,1.9558,N/A,24.555,7.4449,N/A,0.85303,397.45,N/A,N/A,N/A,4.7598,N/A,4.9395,10.4964,N/A,N/A,0.9918,138.9,10.176,7.5093,N/A,N/A,18.018,1.4869,5.5454,1.3264,6.9064,8.0423,15344.49,3.5295,81.898,1340.33,20.8552,4.559,1.6456,57.583,1.4269,37.492,17.457,
+2022-07-18,1.0131,140.16,1.9558,N/A,24.508,7.4435,N/A,0.84708,402.05,N/A,N/A,N/A,4.776,N/A,4.9389,10.5265,N/A,N/A,0.9911,138.9,10.2553,7.513,N/A,N/A,17.7225,1.4839,5.4505,1.3151,6.8266,7.9528,15157.63,3.5004,81.034,1333.33,20.7095,4.5113,1.6432,57.056,1.4153,37.13,17.383,
+2022-07-15,1.0059,139.49,1.9558,N/A,24.561,7.443,N/A,0.84988,403.73,N/A,N/A,N/A,4.7953,N/A,4.9407,10.5943,N/A,N/A,0.9849,138.9,10.2763,7.516,N/A,N/A,17.5451,1.4886,5.4434,1.3147,6.7943,7.8963,15081.58,3.5044,80.316,1333.79,20.9209,4.4752,1.6377,56.678,1.4113,36.866,17.2875,
+2022-07-14,1.0005,139.04,1.9558,N/A,24.417,7.4425,N/A,0.8456,408.78,N/A,N/A,N/A,4.8146,N/A,4.942,10.6019,N/A,N/A,0.9841,138.89,10.2536,7.5122,N/A,N/A,17.494,1.4893,5.4586,1.3162,6.7618,7.8539,15119.56,3.4915,80.0752,1322.29,20.9585,4.4462,1.6437,56.565,1.4065,36.632,17.202,
+2022-07-13,1.0067,138.02,1.9558,N/A,24.397,7.4416,N/A,0.84371,409.35,N/A,N/A,N/A,4.824,N/A,4.9414,10.602,N/A,N/A,0.9829,138.3,10.2428,7.5155,N/A,N/A,17.5629,1.4802,5.4533,1.3073,6.7722,7.9025,15117.08,3.4864,80.1285,1311.4,20.9029,4.4667,1.635,56.669,1.4134,36.377,17.0527,
+2022-07-12,1.0042,137.31,1.9558,N/A,24.582,7.4408,N/A,0.84823,409.98,N/A,N/A,N/A,4.819,N/A,4.9413,10.629,N/A,N/A,0.9883,139.1,10.2754,7.517,N/A,N/A,17.4392,1.49,5.4009,1.3094,6.7518,7.8828,15054.05,3.4987,79.8965,1315.1,20.8883,4.4556,1.6395,56.648,1.4127,36.392,17.1509,
+2022-07-11,1.0098,138.77,1.9558,N/A,24.592,7.4414,N/A,0.8454,408.22,N/A,N/A,N/A,4.7968,N/A,4.943,10.6943,N/A,N/A,0.9908,139.3,10.299,7.518,N/A,N/A,17.5447,1.491,5.3673,1.314,6.7793,7.9265,15131.92,3.5108,80.2435,1320.36,20.7845,4.4704,1.6466,56.574,1.4178,36.585,17.1634,
+2022-07-08,1.0163,138.05,1.9558,N/A,24.614,7.4424,N/A,0.84585,402.45,N/A,N/A,N/A,4.763,N/A,4.9431,10.6665,N/A,N/A,0.9913,139.5,10.263,7.519,N/A,N/A,17.6026,1.4871,5.4345,1.3201,6.8095,7.9769,15210.73,3.5325,80.528,1321.61,20.8477,4.4992,1.6464,56.882,1.4228,36.602,17.1922,
+2022-07-07,1.018,138.11,1.9558,N/A,24.779,7.4405,N/A,0.85105,410.04,N/A,N/A,N/A,4.7721,N/A,4.9448,10.723,N/A,N/A,0.9906,139.3,10.291,7.5193,N/A,N/A,17.5551,1.4883,5.4983,1.3227,6.823,7.9893,15265.27,3.5548,80.6,1324.66,20.9675,4.5077,1.6461,56.939,1.4255,36.74,17.0372,
+2022-07-06,1.0177,137.71,1.9558,N/A,24.778,7.4403,N/A,0.85676,411.8,N/A,N/A,N/A,4.771,N/A,4.944,10.745,N/A,N/A,0.9896,138.5,10.2803,7.5198,N/A,N/A,17.5505,1.4961,5.5116,1.3274,6.8289,7.9864,15287.49,3.5884,80.5321,1331.69,21.0194,4.5028,1.6505,56.779,1.4305,36.78,17.0246,
+2022-07-05,1.029,139.77,1.9558,N/A,24.751,7.4396,N/A,0.85845,407.38,N/A,N/A,N/A,4.7448,N/A,4.9438,10.8031,N/A,N/A,0.9932,139.1,10.285,7.5246,N/A,N/A,17.5049,1.518,5.5141,1.3364,6.9029,8.0748,15487.93,3.6343,81.673,1348.97,21.0171,4.5477,1.6772,57.009,1.4455,36.879,16.9143,
+2022-07-04,1.0455,141.51,1.9558,N/A,24.745,7.4391,N/A,0.8596,401.52,N/A,N/A,N/A,4.71,N/A,4.944,10.7658,N/A,N/A,1.0037,139.3,10.2958,7.5301,N/A,N/A,17.5994,1.5205,5.5663,1.3435,6.9977,8.2033,15684.13,3.6655,82.5067,1353.4,21.1972,4.6138,1.6748,57.487,1.4587,37.298,17.0275,
+2022-07-01,1.0425,141.05,1.9558,N/A,24.753,7.4391,N/A,0.86648,401.11,N/A,N/A,N/A,4.7168,N/A,4.9457,10.7783,N/A,N/A,1.0027,138.7,10.3651,7.531,N/A,N/A,17.4608,1.5382,5.5117,1.3492,6.987,8.1801,15621.64,3.6717,82.3747,1352.58,21.115,4.5943,1.6929,57.452,1.4565,37.186,17.1323,
+2022-06-30,1.0387,141.54,1.9558,N/A,24.739,7.4392,N/A,0.8582,397.04,N/A,N/A,N/A,4.6904,N/A,4.9464,10.73,N/A,N/A,0.996,138.9,10.3485,7.5307,N/A,N/A,17.322,1.5099,5.4229,1.3425,6.9624,8.1493,15552,3.6392,82.113,1351.6,20.9641,4.5781,1.6705,57.15,1.4483,36.754,17.0143,
+2022-06-29,1.0517,143.53,1.9558,N/A,24.739,7.4392,N/A,0.86461,394.28,N/A,N/A,N/A,4.6869,N/A,4.9419,10.6848,N/A,N/A,1.0005,139.9,10.3065,7.5285,N/A,N/A,17.4998,1.5256,5.5163,1.3513,7.0382,8.2532,15612.61,3.6344,83.037,1364.02,21.1375,4.6272,1.6871,57.773,1.4607,36.925,16.9295,
+2022-06-28,1.0561,143.67,1.9558,N/A,24.726,7.4394,N/A,0.8635,398.55,N/A,N/A,N/A,4.6905,N/A,4.9443,10.6543,N/A,N/A,1.0101,139.5,10.337,7.532,N/A,N/A,17.5891,1.521,5.5308,1.3565,7.0775,8.288,15669.91,3.6267,83.408,1361.75,21.088,4.6432,1.6822,57.85,1.4645,37.154,16.9072,
+2022-06-27,1.0572,143.25,1.9558,N/A,24.724,7.4408,N/A,0.862,402.62,N/A,N/A,N/A,4.699,N/A,4.944,10.6713,N/A,N/A,1.0143,139.7,10.408,7.5333,N/A,N/A,17.4794,1.5278,5.5446,1.3639,7.0737,8.2946,15635.36,3.6009,82.9325,1357.68,21.041,4.6559,1.6801,57.9,1.4641,37.361,16.7967,
+2022-06-24,1.0524,142.19,1.9558,N/A,24.731,7.4398,N/A,0.85773,401.34,N/A,N/A,N/A,4.7023,N/A,4.9463,10.694,N/A,N/A,1.0072,139.7,10.4345,7.5295,N/A,N/A,18.2856,1.5248,5.4851,1.3657,7.0478,8.2609,15633.96,3.621,82.3985,1364.09,20.9901,4.6327,1.6731,57.83,1.462,37.36,16.7137,
+2022-06-23,1.0493,142.11,1.9558,N/A,24.75,7.4388,N/A,0.85818,399.6,N/A,N/A,N/A,4.7085,N/A,4.9468,10.705,N/A,N/A,1.013,139.9,10.475,7.5286,N/A,N/A,18.2199,1.5212,5.4515,1.36,7.0367,8.236,15594.75,3.6192,82.1489,1367.21,21.0924,4.623,1.6713,57.44,1.4589,37.261,16.817,
+2022-06-22,1.0521,143.11,1.9558,N/A,24.712,7.4387,N/A,0.85885,396,N/A,N/A,N/A,4.6905,N/A,4.9467,10.6688,N/A,N/A,1.0153,138.7,10.5045,7.5228,N/A,N/A,18.255,1.5254,5.4349,1.366,7.0604,8.2589,15618.98,3.6432,82.4075,1369.29,21.1491,4.6345,1.6835,57.174,1.4615,37.281,16.7985,
+2022-06-21,1.055,143.75,1.9558,N/A,24.69,7.4393,N/A,0.8601,396.48,N/A,N/A,N/A,4.6435,N/A,4.9462,10.646,N/A,N/A,1.0214,138.7,10.3283,7.5205,N/A,N/A,18.3049,1.5177,5.442,1.366,7.068,8.2817,15639.62,3.6505,82.423,1365.09,21.2485,4.6399,1.6675,57.304,1.4612,37.294,16.7881,
+2022-06-20,1.0517,141.94,1.9558,N/A,24.728,7.4387,N/A,0.85748,397.85,N/A,N/A,N/A,4.652,N/A,4.9453,10.6375,N/A,N/A,1.0162,137.3,10.4085,7.5175,N/A,N/A,18.2239,1.5061,5.4117,1.3662,7.0346,8.2558,15589.89,3.639,81.994,1357.54,21.3016,4.6291,1.6549,56.872,1.4589,37.157,16.8603,
+2022-06-17,1.0486,141.21,1.9558,N/A,24.742,7.4384,N/A,0.855,400.53,N/A,N/A,N/A,4.7003,N/A,4.9469,10.6748,N/A,N/A,1.0105,137.7,10.4525,7.5155,N/A,N/A,18.1495,1.5039,5.3824,1.3631,7.0308,8.2314,15537.05,3.6112,81.871,1356.27,21.4474,4.6159,1.6601,56.371,1.4547,36.974,16.7133,
+2022-06-16,1.04,138.24,1.9558,N/A,24.742,7.4386,N/A,0.8555,398.1,N/A,N/A,N/A,4.7138,N/A,4.9443,10.6942,N/A,N/A,1.0142,137.5,10.4588,7.5245,N/A,N/A,18.0126,1.4939,5.2559,1.3446,6.9844,8.1638,15427.31,3.5934,81.1945,1346.88,21.4115,4.5786,1.6608,55.7,1.4451,36.566,16.6052,
+2022-06-15,1.0431,140.49,1.9558,N/A,24.703,7.4392,N/A,0.86328,397.96,N/A,N/A,N/A,4.669,N/A,4.9427,10.6278,N/A,N/A,1.0435,137.5,10.3868,7.5245,N/A,N/A,18.0465,1.5051,5.3164,1.3498,7.0013,8.1883,15361.97,3.6007,81.5142,1346.86,21.4763,4.6037,1.6706,55.627,1.4519,36.529,16.7111,
+2022-06-14,1.0452,140.62,1.9558,N/A,24.749,7.4403,N/A,0.86578,398.68,N/A,N/A,N/A,4.6563,N/A,4.9443,10.622,N/A,N/A,1.0394,138.3,10.3945,7.5238,N/A,N/A,18.06,1.5174,5.3329,1.3522,7.0417,8.2048,15400.02,3.6208,81.559,1346.72,21.4832,4.6224,1.6755,55.669,1.4541,36.566,16.7959,
+2022-06-13,1.0455,140.51,1.9558,N/A,24.724,7.4397,N/A,0.8585,399.3,N/A,N/A,N/A,4.6373,N/A,4.9459,10.616,N/A,N/A,1.0375,138.7,10.3222,7.5215,N/A,N/A,18.0495,1.4998,5.2785,1.3435,7.0434,8.2071,15376.17,3.5994,81.606,1349.93,21.2102,4.6195,1.6635,55.72,1.4538,36.425,16.807,
+2022-06-10,1.0578,141.69,1.9558,N/A,24.705,7.4389,N/A,0.85048,398.48,N/A,N/A,N/A,4.6053,N/A,4.9442,10.5255,N/A,N/A,1.0404,137.7,10.1495,7.5225,N/A,N/A,18.0116,1.4845,5.1718,1.3484,7.0868,8.3031,15393.27,3.5626,82.3355,1344.25,20.8285,4.6564,1.6482,56.101,1.462,36.774,16.5209,
+2022-06-09,1.0743,143.93,1.9558,N/A,24.689,7.4391,N/A,0.85653,396.45,N/A,N/A,N/A,4.5925,N/A,4.9453,10.5045,N/A,N/A,1.0495,138.7,10.1818,7.5223,N/A,N/A,18.5104,1.4985,5.2506,1.3506,7.1722,8.4317,15646.25,3.5859,83.526,1348.99,21.0248,4.7199,1.6673,56.872,1.4779,37.079,16.4132,
+2022-06-08,1.0739,143.92,1.9558,N/A,24.622,7.4386,N/A,0.85575,391.25,N/A,N/A,N/A,4.5698,N/A,4.945,10.4938,N/A,N/A,1.0486,138.9,10.1395,7.5215,N/A,N/A,18.453,1.4917,5.2447,1.3467,7.1785,8.4275,15577.86,3.5848,83.414,1349.34,21.0458,4.7187,1.6644,56.799,1.4769,37.076,16.4626,
+2022-06-07,1.0662,141.66,1.9558,N/A,24.739,7.4395,N/A,0.85365,389.33,N/A,N/A,N/A,4.5813,N/A,4.9426,10.5039,N/A,N/A,1.0423,138.9,10.1843,7.5244,N/A,N/A,17.8702,1.4884,5.1256,1.3437,7.1146,8.3656,15412.37,3.5661,82.873,1340.75,20.8435,4.6865,1.6582,56.421,1.4685,36.768,16.4059,
+2022-06-06,1.0726,140.16,1.9558,N/A,24.715,7.439,N/A,0.85415,388.05,N/A,N/A,N/A,4.5808,N/A,4.9424,10.452,N/A,N/A,1.032,138.3,10.0853,7.5222,N/A,N/A,17.796,1.4842,5.0986,1.3463,7.1223,8.4154,15464.73,3.5697,83.245,1341.13,20.9078,4.7076,1.6428,56.67,1.4732,36.774,16.4142,
+2022-06-03,1.073,139.59,1.9558,N/A,24.708,7.4388,N/A,0.8542,394.78,N/A,N/A,N/A,4.5955,N/A,4.9428,10.4589,N/A,N/A,1.0296,137.9,10.103,7.522,N/A,N/A,17.738,1.4805,5.1643,1.3484,7.1465,8.4167,15498.1,3.5751,83.273,1337.4,20.985,4.7094,1.6409,56.738,1.4741,36.777,16.6153,
+2022-06-02,1.0692,138.72,1.9558,N/A,24.702,7.4391,N/A,0.85195,394.9,N/A,N/A,N/A,4.5787,N/A,4.9398,10.4705,N/A,N/A,1.0264,136.9,10.0845,7.5325,N/A,N/A,17.6175,1.4829,5.1335,1.352,7.135,8.3896,15481.86,3.5705,82.922,1334.06,20.9831,4.6949,1.6413,56.467,1.4701,36.754,16.6143,
+2022-06-01,1.0712,138.68,1.9558,N/A,24.748,7.4393,N/A,0.85158,395.03,N/A,N/A,N/A,4.5913,N/A,4.9428,10.4758,N/A,N/A,1.0305,137.1,10.0438,7.5345,N/A,N/A,17.6223,1.4861,5.0646,1.3536,7.1586,8.4057,15574.33,3.5682,83.051,1331.44,21.0678,4.6951,1.6442,56.182,1.47,36.801,16.609,
+2022-05-31,1.0713,137.36,1.9558,N/A,24.714,7.4394,N/A,0.85138,396.2,N/A,N/A,N/A,4.5805,N/A,4.9408,10.5053,N/A,N/A,1.0281,136.3,10.0983,7.541,N/A,N/A,17.5817,1.4933,5.0965,1.3573,7.1402,8.4063,15580.15,3.5746,83.231,1329.32,20.987,4.6907,1.6459,56.323,1.4687,36.751,16.745,
+2022-05-30,1.0764,137.25,1.9558,N/A,24.712,7.4391,N/A,0.8515,392.18,N/A,N/A,N/A,4.5855,N/A,4.9441,10.518,N/A,N/A,1.0327,136.9,10.1256,7.5305,N/A,N/A,17.6416,1.4982,5.0629,1.3647,7.1735,8.449,15682.41,3.5722,83.475,1331.66,20.8994,4.6998,1.6439,56.322,1.4719,36.7,16.648,
+2022-05-27,1.0722,136.05,1.9558,N/A,24.7,7.4392,N/A,0.84875,392.83,N/A,N/A,N/A,4.5858,N/A,4.9427,10.5293,N/A,N/A,1.0258,137.9,10.179,7.5379,N/A,N/A,17.582,1.4995,5.0959,1.3661,7.1831,8.4165,15583.97,3.597,83.1915,1343.63,21.136,4.6952,1.6426,56.02,1.4679,36.589,16.746,
+2022-05-26,1.0697,135.95,1.9558,N/A,24.676,7.4409,N/A,0.85073,391.72,N/A,N/A,N/A,4.6083,N/A,4.9423,10.5983,N/A,N/A,1.0283,138.1,10.2715,7.5355,N/A,N/A,17.5588,1.511,5.1741,1.3715,7.2024,8.397,15628.91,3.5935,83.0065,1352.69,21.1935,4.7045,1.6541,55.975,1.4709,36.589,16.9312,
+2022-05-25,1.0656,135.34,1.9558,N/A,24.648,7.4405,N/A,0.85295,388.25,N/A,N/A,N/A,4.621,N/A,4.9416,10.5419,N/A,N/A,1.0269,138.3,10.2704,7.5355,N/A,N/A,17.3954,1.5126,5.1736,1.372,7.1334,8.3647,15587.59,3.585,82.6666,1354.61,21.2213,4.6833,1.6539,55.787,1.4676,36.55,16.7628,
+2022-05-24,1.072,136.49,1.9558,N/A,24.663,7.4411,N/A,0.8575,383.33,N/A,N/A,N/A,4.6015,N/A,4.9446,10.5013,N/A,N/A,1.0334,139.3,10.289,7.5285,N/A,N/A,17.2572,1.5152,5.1793,1.3714,7.1449,8.4143,15711.88,3.5848,83.185,1353.65,21.2456,4.7076,1.6656,56.152,1.4722,36.609,16.7814,
+2022-05-23,1.0659,136.05,1.9558,N/A,24.594,7.4413,N/A,0.84783,381.65,N/A,N/A,N/A,4.621,N/A,4.947,10.4918,N/A,N/A,1.031,139.1,10.252,7.5275,N/A,N/A,16.8672,1.4982,5.1623,1.3626,7.085,8.3664,15609,3.5745,82.6795,1344.19,21.1273,4.6782,1.6463,55.686,1.4639,36.41,16.7437,
+2022-05-20,1.0577,135.34,1.9558,N/A,24.67,7.4424,N/A,0.8482,382.93,N/A,N/A,N/A,4.6365,N/A,4.9477,10.4915,N/A,N/A,1.028,138.5,10.262,7.5335,N/A,N/A,16.8201,1.498,5.1989,1.3526,7.0638,8.2999,15501.99,3.533,82.1617,1340.58,21.0314,4.6422,1.6518,55.181,1.4588,36.284,16.7131,
+2022-05-19,1.0525,134.46,1.9558,N/A,24.7,7.4423,N/A,0.84728,385.83,N/A,N/A,N/A,4.6423,N/A,4.9474,10.5098,N/A,N/A,1.0265,139.5,10.3102,7.5395,N/A,N/A,16.8037,1.5036,5.2094,1.349,7.1028,8.2594,15416.76,3.5623,81.7115,1343.21,21.0043,4.6363,1.6551,55.14,1.4576,36.343,16.8315,
+2022-05-18,1.0523,135.76,1.9558,N/A,24.647,7.4419,N/A,0.8467,382.88,N/A,N/A,N/A,4.6443,N/A,4.9473,10.4675,N/A,N/A,1.0486,138.9,10.2125,7.535,N/A,N/A,16.7811,1.498,5.1974,1.3488,7.0972,8.2591,15446,3.526,81.6455,1332.76,20.9204,4.6254,1.6548,55.077,1.4598,36.399,16.7313,
+2022-05-17,1.0541,136.32,1.9558,N/A,24.712,7.4414,N/A,0.844,386.3,N/A,N/A,N/A,4.6488,N/A,4.9478,10.4393,N/A,N/A,1.0457,138.7,10.178,7.5245,N/A,N/A,16.6027,1.4993,5.2621,1.3517,7.0899,8.2744,15433.23,3.5387,81.6515,1333.66,21.0273,4.6211,1.6561,55.137,1.4589,36.361,16.844,
+2022-05-16,1.0422,135.01,1.9558,N/A,24.71,7.4418,N/A,0.85045,385.85,N/A,N/A,N/A,4.6675,N/A,4.9469,10.4978,N/A,N/A,1.0479,138.3,10.2188,7.5225,N/A,N/A,16.3121,1.5057,5.2819,1.3473,7.0786,8.1812,15294.29,3.5474,81.081,1337.9,20.9324,4.5836,1.6601,54.705,1.4531,36.274,16.9195,
+2022-05-13,1.0385,133.91,1.9558,N/A,24.74,7.4412,N/A,0.85115,385,N/A,N/A,N/A,4.6883,N/A,4.9455,10.4905,N/A,N/A,1.0385,140.1,10.2043,7.52,N/A,N/A,16.0687,1.5067,5.3204,1.3505,7.0513,8.1522,15193.55,3.5586,80.4315,1330.83,20.988,4.5673,1.6633,54.449,1.45,36.109,16.7789,
+2022-05-12,1.0408,133.85,1.9558,N/A,24.925,7.4413,N/A,0.85293,382.2,N/A,N/A,N/A,4.668,N/A,4.947,10.5648,N/A,N/A,1.0377,139.7,10.2898,7.5235,N/A,N/A,16.0132,1.5163,5.4161,1.3569,7.0691,8.1702,15255.73,3.5981,80.667,1341.98,21.2531,4.5725,1.6692,54.589,1.4529,36.15,16.8806,
+2022-05-11,1.0553,137.07,1.9558,N/A,25.365,7.4393,N/A,0.85393,379.13,N/A,N/A,N/A,4.6575,N/A,4.947,10.526,N/A,N/A,1.0446,139.3,10.1793,7.5365,N/A,N/A,16.1851,1.5055,5.3859,1.3685,7.0893,8.2839,15308.87,3.6148,81.4935,1343.99,21.387,4.6185,1.6645,54.992,1.4622,36.492,16.9275,
+2022-05-10,1.0554,137.38,1.9558,N/A,25.014,7.4386,N/A,0.85595,380.15,N/A,N/A,N/A,4.6763,N/A,4.9458,10.6075,N/A,N/A,1.0479,139.5,10.2315,7.5385,N/A,N/A,16.0883,1.5162,5.4232,1.3707,7.0967,8.2847,15349.06,3.6587,81.5425,1346.56,21.4716,4.6248,1.6707,55.289,1.4667,36.448,17.005,
+2022-05-09,1.0559,138.1,1.9558,N/A,25.055,7.4385,N/A,0.85235,383.23,N/A,N/A,N/A,4.6985,N/A,4.9467,10.5818,N/A,N/A,1.0462,139.5,10.0583,7.5335,N/A,N/A,15.8941,1.5048,5.4321,1.3656,7.0886,8.2887,15367.67,3.6239,81.7415,1345.48,21.4341,4.6285,1.6584,55.67,1.4676,36.497,17.1332,
+2022-05-06,1.057,137.9,1.9558,N/A,24.665,7.44,N/A,0.85625,381.47,N/A,N/A,N/A,4.7028,N/A,4.949,10.4686,N/A,N/A,1.0419,138.3,9.9808,7.5336,N/A,N/A,15.8078,1.4888,5.3183,1.356,7.0506,8.2969,15312.44,3.5965,81.298,1343.9,21.3555,4.6191,1.644,55.467,1.4642,36.303,16.9614,
+2022-05-05,1.0568,137.18,1.9558,N/A,24.606,7.4405,N/A,0.8519,378.65,N/A,N/A,N/A,4.6673,N/A,4.9485,10.3748,N/A,N/A,1.0355,138,9.8463,7.5398,N/A,N/A,15.7051,1.4669,5.2192,1.3483,6.9944,8.2948,15250.92,3.5916,80.6185,1330.89,21.2069,4.5955,1.6273,55.364,1.4561,36.026,16.5862,
+2022-05-04,1.0531,136.84,1.9558,N/A,24.644,7.4409,N/A,0.84194,377.55,N/A,N/A,N/A,4.6875,N/A,4.947,10.3968,N/A,N/A,1.0324,137.2,9.9042,7.5499,N/A,N/A,15.5769,1.478,5.24,1.3498,6.9594,8.2655,15201.44,3.5487,80.4035,1331.45,21.2947,4.5847,1.6333,55.26,1.4559,36.137,16.6489,
+2022-05-03,1.0556,137.06,1.9558,N/A,24.662,7.4403,N/A,0.8413,382.15,N/A,N/A,N/A,4.6925,N/A,4.9475,10.3978,N/A,N/A,1.0272,137.6,9.909,7.5555,N/A,N/A,15.6941,1.4825,5.3143,1.357,6.9759,8.2838,15288.47,3.5597,80.842,1335.64,21.5025,4.5956,1.6366,55.455,1.4605,36.387,16.8303,
+2022-05-02,1.0524,136.63,1.9558,N/A,24.671,7.4391,N/A,0.8381,378.51,N/A,N/A,N/A,4.685,N/A,4.9478,10.4035,N/A,N/A,1.0253,137.2,9.9248,7.561,N/A,N/A,15.6697,1.4913,5.248,1.356,6.9548,8.2581,15293.41,3.5277,80.497,1333.71,21.4758,4.5816,1.6362,55.229,1.4585,36.208,16.7383,
+2022-04-29,1.054,137.01,1.9558,N/A,24.605,7.4415,N/A,0.83908,378.71,N/A,N/A,N/A,4.678,N/A,4.9479,10.2958,N/A,N/A,1.0229,137.8,9.7525,7.5667,N/A,N/A,15.6385,1.4699,5.1608,1.3426,6.9441,8.2703,15301.52,3.4993,80.638,1326.71,21.4181,4.5886,1.6119,55.2,1.4545,36.026,16.6473,
+2022-04-28,1.0485,137.13,1.9558,N/A,24.526,7.4421,N/A,0.8435,377.06,N/A,N/A,N/A,4.6891,N/A,4.9479,10.3594,N/A,N/A,1.0216,137.8,9.899,7.5703,N/A,N/A,15.5362,1.4814,5.2465,1.3498,6.9381,8.2267,15222.05,3.5096,80.367,1337.82,21.4531,4.5741,1.6221,54.845,1.4556,36.152,16.7472,
+2022-04-27,1.0583,135.57,1.9558,N/A,24.55,7.441,N/A,0.84215,379.74,N/A,N/A,N/A,4.7043,N/A,4.948,10.4035,N/A,N/A,1.0229,138.2,9.7838,7.565,N/A,N/A,15.6857,1.4828,5.3045,1.3572,6.9377,8.3045,15259.86,3.5178,81.0705,1341.98,21.6259,4.6142,1.6118,55.195,1.4602,36.331,16.8406,
+2022-04-26,1.0674,136.15,1.9558,N/A,24.423,7.4393,N/A,0.84135,374.46,N/A,N/A,N/A,4.6466,N/A,4.9458,10.3935,N/A,N/A,1.0229,138.4,9.7943,7.5625,N/A,N/A,15.7944,1.4828,5.249,1.3613,6.9837,8.3735,15365.76,3.5147,81.7265,1340.02,21.6538,4.6485,1.6102,55.681,1.4666,36.596,16.7787,
+2022-04-25,1.0746,137.73,1.9558,N/A,24.418,7.4391,N/A,0.8433,374.08,N/A,N/A,N/A,4.6398,N/A,4.9455,10.3476,N/A,N/A,1.0267,139.2,9.7018,7.562,N/A,N/A,15.864,1.4972,5.1953,1.3709,7.0398,8.4325,15533.84,3.5306,82.321,1344.49,21.8989,4.6815,1.624,56.259,1.4757,36.542,16.8549,
+2022-04-22,1.0817,138.83,1.9558,N/A,24.32,7.4402,N/A,0.83925,370.35,N/A,N/A,N/A,4.6336,N/A,4.9455,10.278,N/A,N/A,1.0336,139.8,9.6255,7.5625,N/A,N/A,15.9446,1.4816,5.0926,1.3714,7.0332,8.4859,15603.47,3.5288,82.6943,1344.04,22.0034,4.6784,1.6193,56.721,1.4784,36.724,16.8652,
+2022-04-21,1.0887,139.61,1.9558,N/A,24.38,7.4403,N/A,0.83523,370.6,N/A,N/A,N/A,4.63,N/A,4.945,10.2553,N/A,N/A,1.0335,139,9.5788,7.5635,N/A,N/A,15.9983,1.4653,5.0324,1.36,7.0228,8.5406,15624.02,3.5153,82.965,1348.33,21.8836,4.6716,1.6053,57.081,1.482,36.891,16.5996,
+2022-04-20,1.083,138.53,1.9558,N/A,24.409,7.4405,N/A,0.82965,371.36,N/A,N/A,N/A,4.6338,N/A,4.9436,10.23,N/A,N/A,1.0254,139.2,9.5443,7.561,N/A,N/A,15.8892,1.4581,5.0481,1.3579,6.9448,8.494,15537.05,3.4908,82.6348,1337.89,21.6392,4.6415,1.595,56.747,1.4779,36.567,16.3019,
+2022-04-19,1.0803,138.4,1.9558,N/A,24.424,7.4391,N/A,0.82955,374.12,N/A,N/A,N/A,4.6553,N/A,4.9411,10.3408,N/A,N/A,1.0208,139.8,9.5228,7.562,N/A,N/A,15.8416,1.4663,5.0261,1.3631,6.9008,8.4698,15498.35,3.5038,82.6038,1339.46,21.4725,4.5961,1.6016,56.683,1.4763,36.466,16.0401,
+2022-04-14,1.0878,136.32,1.9558,N/A,24.42,7.4389,N/A,0.82908,376.57,N/A,N/A,N/A,4.6478,N/A,4.9459,10.3008,N/A,N/A,1.0189,140.4,9.5313,7.5587,N/A,N/A,15.9046,1.4612,5.1226,1.3663,6.932,8.5298,15621.3,3.4896,82.814,1334.71,21.5941,4.603,1.5957,56.759,1.4732,36.615,15.9331,
+2022-04-13,1.0826,136.26,1.9558,N/A,24.45,7.4377,N/A,0.8328,378.45,N/A,N/A,N/A,4.6453,N/A,4.9415,10.3323,N/A,N/A,1.0116,140.2,9.5693,7.5538,N/A,N/A,15.7992,1.4603,5.0449,1.37,6.8939,8.4867,15549.1,3.4782,82.478,1328.47,21.417,4.5799,1.5991,56.446,1.4769,36.305,15.682,
+2022-04-12,1.0861,136.29,1.9558,N/A,24.45,7.4379,N/A,0.83455,377.78,N/A,N/A,N/A,4.6552,N/A,4.9417,10.332,N/A,N/A,1.0131,139.6,9.5395,7.5513,N/A,N/A,15.9548,1.4599,5.0944,1.3724,6.9199,8.5112,15609.66,3.4972,82.7285,1335.49,21.5616,4.5972,1.5874,56.574,1.4803,36.531,15.849,
+2022-04-11,1.09,137.01,1.9558,N/A,24.429,7.4375,N/A,0.83693,378.27,N/A,N/A,N/A,4.6456,N/A,4.9397,10.3128,N/A,N/A,1.018,140,9.5478,7.5519,N/A,N/A,16.0485,1.4654,5.155,1.3738,6.9405,8.544,15658.28,3.501,82.7085,1345.23,21.8653,4.6112,1.5938,56.753,1.4874,36.613,15.9127,
+2022-04-08,1.0861,134.87,1.9558,N/A,24.479,7.4372,N/A,0.83355,375.66,N/A,N/A,N/A,4.6437,N/A,4.9425,10.2768,N/A,N/A,1.0155,139.6,9.508,7.549,N/A,N/A,16.0237,1.4552,5.1583,1.3675,6.9115,8.5134,15601.96,3.501,82.389,1333.12,21.8729,4.585,1.5849,55.99,1.4801,36.488,15.9968,
+2022-04-07,1.0916,135.32,1.9558,N/A,24.512,7.4378,N/A,0.8345,379.26,N/A,N/A,N/A,4.637,N/A,4.9419,10.313,N/A,N/A,1.0185,141,9.5595,7.5562,N/A,N/A,16.0929,1.4578,5.146,1.3704,6.9448,8.5554,15692.35,3.5259,82.951,1330.92,21.9806,4.6046,1.5816,56.114,1.4848,36.541,16.052,
+2022-04-06,1.0923,135.3,1.9558,N/A,24.441,7.4378,N/A,0.83473,377.77,N/A,N/A,N/A,4.6328,N/A,4.9433,10.2855,N/A,N/A,1.0187,141.4,9.5523,7.547,N/A,N/A,16.0998,1.4431,5.0996,1.3647,6.9498,8.5617,15683.36,3.5199,82.8343,1330.44,21.8759,4.604,1.5718,56.167,1.4844,36.701,15.9934,
+2022-04-05,1.0969,134.76,1.9558,N/A,24.338,7.4378,N/A,0.8349,370.93,N/A,N/A,N/A,4.6265,N/A,4.9438,10.2593,N/A,N/A,1.0141,141.6,9.5398,7.5399,N/A,N/A,16.15,1.4374,5.0384,1.3647,6.9783,8.5917,15732.77,3.5152,82.635,1330.81,21.7474,4.6185,1.5657,56.194,1.4867,36.697,15.9529,
+2022-04-04,1.1005,135.08,1.9558,N/A,24.32,7.4385,N/A,0.8389,369.15,N/A,N/A,N/A,4.6375,N/A,4.9432,10.3849,N/A,N/A,1.0203,141.8,9.5489,7.5455,N/A,N/A,16.183,1.4651,5.1162,1.3749,7.0026,8.6226,15783.89,3.5312,83.118,1338.41,21.82,4.643,1.586,56.521,1.4938,36.894,16.0957,
+2022-04-01,1.1052,135.35,1.9558,N/A,24.376,7.4388,N/A,0.84145,368.12,N/A,N/A,N/A,4.6401,N/A,4.9452,10.332,N/A,N/A,1.0217,142,9.6628,7.5675,N/A,N/A,16.2411,1.4696,5.2188,1.3805,7.0311,8.6596,15887.5,3.5315,83.9847,1345.61,21.9087,4.6534,1.5911,57.084,1.4985,36.941,16.1685,
+2022-03-31,1.1101,135.17,1.9558,N/A,24.375,7.4379,N/A,0.84595,369.77,N/A,N/A,N/A,4.6531,N/A,4.9463,10.337,N/A,N/A,1.0267,142,9.711,7.574,N/A,N/A,16.2823,1.4829,5.3009,1.3896,7.0403,8.6918,15947,3.5243,84.134,1347.37,22.0903,4.6677,1.6014,57.514,1.5028,36.911,16.1727,
+2022-03-30,1.1126,135.47,1.9558,N/A,24.45,7.4391,N/A,0.84563,368.13,N/A,N/A,N/A,4.6679,N/A,4.9477,10.3498,N/A,N/A,1.0309,142.2,9.6398,7.572,N/A,N/A,16.3296,1.4809,5.2808,1.3891,7.0666,8.7081,15957.24,3.5399,84.38,1346.97,22.1557,4.6779,1.5947,57.906,1.5064,37.144,16.1288,
+2022-03-29,1.1085,136.66,1.9558,N/A,24.464,7.4388,N/A,0.8444,369.8,N/A,N/A,N/A,4.6594,N/A,4.9478,10.329,N/A,N/A,1.0362,142.2,9.5995,7.5815,N/A,N/A,16.3275,1.4795,5.2434,1.387,7.055,8.6767,15896.31,3.5505,83.9685,1345.62,22.1561,4.6707,1.6054,57.602,1.5051,37.29,16.1804,
+2022-03-28,1.0966,135.93,1.9558,N/A,24.65,7.4393,N/A,0.83643,374.13,N/A,N/A,N/A,4.718,N/A,4.9483,10.4225,N/A,N/A,1.0257,142.8,9.5123,7.5735,N/A,N/A,16.275,1.459,5.2133,1.3702,6.9862,8.5861,15737.77,3.5313,83.4825,1342.49,21.9841,4.6238,1.5838,57.08,1.4921,37.027,15.9925,
+2022-03-25,1.1002,134.07,1.9558,N/A,24.645,7.4404,N/A,0.8338,373.81,N/A,N/A,N/A,4.7307,N/A,4.9487,10.3505,N/A,N/A,1.0207,142.2,9.5205,7.5754,N/A,N/A,16.3304,1.4624,5.2634,1.3781,7.0007,8.6117,15777.69,3.5351,83.8235,1343.32,21.9908,4.6324,1.5787,57.322,1.4919,36.906,16.0386,
+2022-03-24,1.0978,133.71,1.9558,N/A,24.72,7.4397,N/A,0.83288,374.44,N/A,N/A,N/A,4.7421,N/A,4.9489,10.3555,N/A,N/A,1.0225,141.2,9.4923,7.5745,N/A,N/A,16.2917,1.4668,5.3057,1.3806,6.9933,8.5897,15778.31,3.5461,83.879,1342.53,22.177,4.6396,1.5812,57.426,1.4912,36.837,16.1478,
+2022-03-23,1.0985,132.65,1.9558,N/A,24.605,7.4381,N/A,0.8328,372.25,N/A,N/A,N/A,4.7052,N/A,4.9463,10.4005,N/A,N/A,1.0269,141.4,9.6425,7.571,N/A,N/A,16.3108,1.4728,5.3903,1.384,7.0003,8.5948,15792.11,3.5407,83.9675,1337.76,22.1978,4.6401,1.5822,57.565,1.4919,36.965,16.2501,
+2022-03-22,1.1024,132.96,1.9558,N/A,24.679,7.4402,N/A,0.83228,371.23,N/A,N/A,N/A,4.6851,N/A,4.9463,10.3822,N/A,N/A,1.0275,142.7,9.6233,7.575,N/A,N/A,16.3432,1.4802,5.4105,1.3867,7.0137,8.6285,15808.01,3.5521,83.9145,1343.81,22.3667,4.6483,1.586,57.749,1.4957,36.881,16.343,
+2022-03-21,1.1038,131.57,1.9558,N/A,24.683,7.4411,N/A,0.83775,374.48,N/A,N/A,N/A,4.696,N/A,4.947,10.4088,N/A,N/A,1.0278,142.7,9.6575,7.5733,N/A,N/A,16.3773,1.4897,5.502,1.3898,7.0152,8.6387,15826.61,3.5637,84.1835,1342.62,22.48,4.6415,1.5997,57.817,1.496,37.038,16.4543,
+2022-03-18,1.1008,131.4,1.9558,N/A,24.837,7.4423,N/A,0.83925,375.33,N/A,N/A,N/A,4.7135,N/A,4.9483,10.4303,N/A,N/A,1.0314,142.9,9.694,7.5685,N/A,N/A,16.3054,1.4945,5.5784,1.3911,7.0031,8.6101,15782.11,3.5761,83.7825,1337.31,22.5905,4.6157,1.6026,57.622,1.4952,36.745,16.5347,
+2022-03-17,1.1051,131.27,1.9558,N/A,24.777,7.4439,N/A,0.84315,372.05,N/A,N/A,N/A,4.6889,N/A,4.9465,10.4503,N/A,N/A,1.0385,142.1,9.78,7.573,N/A,N/A,16.3123,1.5055,5.6339,1.3998,7.0176,8.6391,15835.97,3.5777,83.8435,1340.02,22.788,4.6364,1.613,57.69,1.498,36.767,16.5286,
+2022-03-16,1.0994,130.05,1.9558,N/A,24.687,7.4412,N/A,0.83988,371.18,N/A,N/A,N/A,4.6765,N/A,4.9473,10.4205,N/A,N/A,1.0336,143.5,9.7988,7.5725,N/A,N/A,16.1783,1.5165,5.6523,1.3967,6.9817,8.5996,15690.36,3.5872,83.7805,1353.77,22.854,4.6147,1.6168,57.433,1.4966,36.681,16.5574,
+2022-03-15,1.0991,129.67,1.9558,N/A,24.867,7.441,N/A,0.84053,371.41,N/A,N/A,N/A,4.7355,N/A,4.9482,10.526,N/A,N/A,1.0322,144.9,9.849,7.575,N/A,N/A,16.0968,1.5234,5.6385,1.4099,7.0117,8.6026,15710.44,3.6088,83.9555,1366.05,22.9352,4.6239,1.6216,57.536,1.4993,36.842,16.6249,
+2022-03-14,1.096,129.3,1.9558,N/A,24.89,7.4405,N/A,0.83915,373.88,N/A,N/A,N/A,4.7218,N/A,4.949,10.5368,N/A,N/A,1.0249,145.1,9.8588,7.5745,N/A,N/A,16.2,1.5137,5.5286,1.3978,6.9738,8.5815,15678.53,3.586,83.931,1357.77,22.8311,4.6087,1.613,57.398,1.4947,36.59,16.5029,
+2022-03-11,1.099,128.46,1.9558,N/A,25.213,7.4402,N/A,0.8397,380.92,N/A,N/A,N/A,4.782,N/A,4.949,10.646,N/A,N/A,1.023,144.9,9.8033,7.5713,N/A,N/A,16.2554,1.5017,5.5077,1.4024,6.9633,8.6007,15696.64,3.5683,83.9875,1354.04,22.9524,4.6098,1.6053,57.461,1.4949,36.542,16.4896,
+2022-03-10,1.1084,128.54,1.9558,N/A,25.316,7.4401,N/A,0.84175,381.63,N/A,N/A,N/A,4.8239,N/A,4.9491,10.7073,N/A,N/A,1.027,145.5,9.919,7.5665,N/A,N/A,16.574,1.5109,5.5958,1.4189,7.0063,8.6688,15824.95,3.6219,84.607,1360.48,23.3153,4.6414,1.6185,57.825,1.5058,36.71,16.7264,
+2022-03-09,1.0993,127.31,1.9558,N/A,25.364,7.444,N/A,0.8357,379.66,N/A,N/A,N/A,4.8196,N/A,4.9485,10.734,N/A,N/A,1.0198,145.3,9.798,7.5625,N/A,N/A,16.1323,1.4991,5.5201,1.4108,6.9454,8.5974,15710.06,3.5978,84.2025,1357.08,23.2145,4.6028,1.6055,57.259,1.4966,36.326,16.656,
+2022-03-08,1.0892,126.03,1.9558,N/A,25.642,7.4441,N/A,0.83185,388.28,N/A,N/A,N/A,4.9103,N/A,4.9494,10.8803,N/A,N/A,1.0111,145.9,9.7925,7.5715,N/A,N/A,15.8183,1.4971,5.5346,1.3978,6.8805,8.5183,15639.76,3.6022,83.924,1344.71,23.2866,4.5556,1.5958,56.9,1.4856,36.156,16.7051,
+2022-03-07,1.0895,125.55,1.9558,N/A,25.584,7.4406,N/A,0.82625,393.25,N/A,N/A,N/A,4.9525,N/A,4.9494,10.8573,N/A,N/A,1.0069,145.8,9.8325,7.56,N/A,N/A,15.6577,1.4751,5.5065,1.3864,6.8846,8.5154,15685.76,3.5653,83.8125,1338.45,23.0249,4.5426,1.5861,56.832,1.4831,35.866,16.6951,
+2022-03-04,1.0929,126.17,1.9558,N/A,25.737,7.4394,N/A,0.82388,386.54,N/A,N/A,N/A,4.853,N/A,4.9495,10.7935,N/A,N/A,1.0056,144.2,9.8358,7.5584,N/A,N/A,15.5681,1.4872,5.5313,1.3937,6.9065,8.5411,15725.3,3.5603,83.4354,1332.23,22.7543,4.5661,1.6005,56.814,1.4872,35.776,16.8044,
+2022-03-03,1.1076,128.18,1.9558,N/A,25.634,7.4399,N/A,0.82773,378.64,N/A,N/A,N/A,4.7691,N/A,4.9496,10.7688,N/A,N/A,1.0192,143.4,9.8418,7.57,N/A,N/A,15.6897,1.5139,5.6041,1.3992,6.9996,8.6547,15934.42,3.5872,84.174,1334.2,22.8945,4.637,1.6329,57.293,1.5042,36.063,16.8798,
+2022-03-02,1.1106,128.08,1.9558,N/A,25.866,7.4387,N/A,0.83316,382.31,N/A,N/A,N/A,4.8021,N/A,4.9493,10.788,N/A,N/A,1.0216,143,9.8826,7.574,N/A,N/A,15.628,1.5272,5.7313,1.4088,7.0153,8.6785,15980.03,3.5954,84.1765,1338.99,22.999,4.6595,1.6404,57.206,1.5059,36.339,17.1904,
+2022-03-01,1.1162,128.15,1.9558,N/A,25.465,7.4377,N/A,0.8329,379.6,N/A,N/A,N/A,4.7947,N/A,4.949,10.6893,N/A,N/A,1.0247,142,9.8598,7.567,117.201,N/A,15.5509,1.5365,5.7598,1.4158,7.0462,8.7234,16033.36,3.6152,84.5015,1342.6,22.8558,4.6802,1.6484,57.295,1.515,36.505,17.2145,
+2022-02-28,1.1199,129.31,1.9558,N/A,24.997,7.4404,N/A,0.8355,369.72,N/A,N/A,N/A,4.6835,N/A,4.9484,10.6055,N/A,N/A,1.0336,141.8,9.9465,7.5655,115.4842,N/A,15.4532,1.5508,5.7828,1.4264,7.067,8.7514,16100.72,3.63,84.554,1347.62,22.9011,4.7019,1.6628,57.432,1.5201,36.593,17.2863,
+2022-02-25,1.1216,129.64,1.9558,N/A,24.66,7.4418,N/A,0.8374,365.28,N/A,N/A,N/A,4.6369,N/A,4.9479,10.5848,N/A,N/A,1.0398,140.8,9.9756,7.5535,92.5673,N/A,15.4799,1.5541,5.738,1.4325,7.0828,8.7578,16088.71,3.6389,84.347,1346.44,22.9145,4.7107,1.6651,57.549,1.5176,36.441,17.0315,
+2022-02-24,1.1163,128.28,1.9558,N/A,25.09,7.4405,N/A,0.83463,368.63,N/A,N/A,N/A,4.6554,N/A,4.9501,10.7338,N/A,N/A,1.032,142,10.0878,7.552,95.7175,N/A,16.0525,1.5593,5.6874,1.4316,7.0601,8.7178,16074,3.6618,84.296,1347.7,22.9355,4.6896,1.6692,57.45,1.5125,36.514,17.1634,
+2022-02-23,1.1344,130.58,1.9558,N/A,24.473,7.4388,N/A,0.83463,357.25,N/A,N/A,N/A,4.5481,N/A,4.9468,10.5658,N/A,N/A,1.0431,141.2,10.0335,7.5362,90.8791,N/A,15.6871,1.5592,5.6808,1.4394,7.1669,8.8529,16270.12,3.6515,84.6135,1350.23,22.9079,4.748,1.6679,57.98,1.5253,36.601,17.0508,
+2022-02-22,1.1342,130.54,1.9558,N/A,24.496,7.4392,N/A,0.83685,355.89,N/A,N/A,N/A,4.5447,N/A,4.9464,10.5996,N/A,N/A,1.0422,141.2,10.1018,7.537,89.8055,N/A,15.6959,1.5739,5.7677,1.4441,7.1771,8.8495,16293.92,3.6584,84.758,1353.34,23.033,4.7472,1.6848,58.208,1.5268,36.748,17.1768,
+2022-02-21,1.1338,130.2,1.9558,N/A,24.345,7.4397,N/A,0.83298,357.54,N/A,N/A,N/A,4.5351,N/A,4.9448,10.6535,N/A,N/A,1.0387,141.4,10.1738,7.536,89.0866,N/A,15.4689,1.5751,5.8045,1.4454,7.1831,8.8443,16276.34,3.6433,84.677,1353.02,22.9951,4.7387,1.687,58.3,1.5265,36.588,17.1895,
+2022-02-18,1.1354,130.59,1.9558,N/A,24.337,7.4382,N/A,0.83425,356.37,N/A,N/A,N/A,4.5201,N/A,4.9453,10.5796,N/A,N/A,1.0452,140.8,10.1465,7.5355,86.2815,N/A,15.4678,1.5754,5.8435,1.4424,7.184,8.8566,16304.49,3.6276,84.6525,1356.45,23.027,4.7528,1.6896,58.403,1.5255,36.435,17.0858,
+2022-02-17,1.137,130.84,1.9558,N/A,24.383,7.4398,N/A,0.83493,356.08,N/A,N/A,N/A,4.5065,N/A,4.9432,10.593,N/A,N/A,1.0466,141.6,10.1225,7.533,86.388,N/A,15.4945,1.5786,5.8495,1.4439,7.206,8.8692,16291.53,3.6231,85.2935,1360.7,23.0367,4.7612,1.695,58.314,1.5278,36.537,16.9893,
+2022-02-16,1.1372,131.56,1.9558,N/A,24.365,7.441,N/A,0.8394,355.65,N/A,N/A,N/A,4.4961,N/A,4.9436,10.5363,N/A,N/A,1.0516,141.4,10.1095,7.5295,85.3679,N/A,15.481,1.5859,5.8765,1.4416,7.2101,8.8712,16232.55,3.6256,85.3885,1361.31,23.1718,4.7595,1.7108,58.346,1.5291,36.771,17.214,
+2022-02-15,1.1345,131.18,1.9558,N/A,24.419,7.4422,N/A,0.83765,355.33,N/A,N/A,N/A,4.5036,N/A,4.941,10.5739,N/A,N/A,1.0483,141.2,10.0893,7.529,85.5025,N/A,15.4716,1.5888,5.8977,1.4433,7.1969,8.8527,16187.89,3.6596,85.443,1357.5,23.1113,4.7493,1.7143,58.144,1.5265,36.724,17.1767,
+2022-02-14,1.1316,130.6,1.9558,N/A,24.527,7.4411,N/A,0.8372,357.06,N/A,N/A,N/A,4.54,N/A,4.9457,10.6158,N/A,N/A,1.0472,142.6,10.0693,7.5293,86.348,N/A,15.351,1.5902,5.8965,1.4431,7.1937,8.8283,16190.53,3.6835,85.4715,1354.5,23.1331,4.742,1.7112,58.114,1.5247,36.8,17.131,
+2022-02-11,1.1417,132.24,1.9558,N/A,24.405,7.44,N/A,0.83958,353.38,N/A,N/A,N/A,4.5204,N/A,4.9458,10.553,N/A,N/A,1.0557,141.8,10.0732,7.5312,85.855,N/A,15.4066,1.5927,5.9263,1.4498,7.2564,8.9054,16339.46,3.6958,85.8535,1363.68,23.3183,4.7832,1.7085,58.482,1.5339,37.282,17.2736,
+2022-02-10,1.1439,132.42,1.9558,N/A,24.35,7.4404,N/A,0.84248,354.02,N/A,N/A,N/A,4.4921,N/A,4.9451,10.5275,N/A,N/A,1.0571,141.8,10.0693,7.5275,85.0187,N/A,15.4838,1.5894,5.9668,1.4498,7.2722,8.9142,16390.21,3.6796,85.9373,1367.52,23.3584,4.7855,1.7076,58.583,1.5345,37.331,17.3078,
+2022-02-09,1.1435,132.04,1.9558,N/A,24.288,7.4437,N/A,0.84255,352.94,N/A,N/A,N/A,4.5135,N/A,4.9449,10.4075,N/A,N/A,1.0555,142.2,10.0585,7.5285,85.5289,N/A,15.551,1.5933,6.0198,1.4514,7.2759,8.9106,16390.99,3.6817,85.5765,1365.72,23.4719,4.7853,1.7107,58.603,1.5349,37.404,17.5281,
+2022-02-08,1.1408,131.68,1.9558,N/A,24.259,7.4437,N/A,0.84363,353.09,N/A,N/A,N/A,4.5312,N/A,4.945,10.4433,N/A,N/A,1.0545,142.4,10.0758,7.5215,85.7797,N/A,15.5558,1.6025,6.0209,1.4505,7.2636,8.8923,16418.4,3.6753,85.2545,1367.88,23.5601,4.774,1.7196,58.715,1.5349,37.606,17.638,
+2022-02-07,1.1447,131.59,1.9558,N/A,24.222,7.4443,N/A,0.84685,353.48,N/A,N/A,N/A,4.5432,N/A,4.9461,10.4483,N/A,N/A,1.0571,143.4,10.0658,7.52,86.5824,N/A,15.5235,1.6097,6.0541,1.4546,7.2807,8.9202,16478.97,3.6547,85.5345,1371.76,23.575,4.7909,1.7278,58.978,1.5389,37.735,17.7,
+2022-02-04,1.1464,131.72,1.9558,N/A,24.36,7.4432,N/A,0.84593,352.92,N/A,N/A,N/A,4.5474,N/A,4.9466,10.4465,N/A,N/A,1.0567,142.8,10.0483,7.5275,87.3095,N/A,15.5072,1.6165,6.083,1.4583,7.2923,8.9286,16493.16,3.6741,85.6445,1374.04,23.5856,4.7914,1.7287,58.754,1.5419,37.797,17.5875,
+2022-02-03,1.1286,129.63,1.9558,N/A,24.135,7.4388,N/A,0.83208,353.94,N/A,N/A,N/A,4.5315,N/A,4.9461,10.387,N/A,N/A,1.0407,142.4,9.9545,7.5295,86.1788,N/A,15.3047,1.5849,5.9843,1.4334,7.1795,8.7966,16243.28,3.5949,84.518,1358.42,23.2359,4.7215,1.7001,57.608,1.5212,37.424,17.2864,
+2022-02-02,1.1323,129.37,1.9558,N/A,24.298,7.4383,N/A,0.83395,354.45,N/A,N/A,N/A,4.5449,N/A,4.9463,10.385,N/A,N/A,1.0399,143.2,9.9228,7.526,85.815,N/A,15.3011,1.5828,5.9677,1.433,7.2026,8.8245,16243.98,3.5777,84.613,1359.23,23.2134,4.7392,1.701,57.785,1.5254,37.575,17.3459,
+2022-02-01,1.126,129.12,1.9558,N/A,24.335,7.4407,N/A,0.83498,356.38,N/A,N/A,N/A,4.5804,N/A,4.9465,10.4438,N/A,N/A,1.0374,143.8,9.9638,7.5275,86.3238,N/A,15.0644,1.5868,5.9572,1.4299,7.1625,8.7779,16126.29,3.566,84.197,1353.61,23.1296,4.7129,1.7032,57.516,1.5199,37.378,17.1633,
+2022-01-31,1.1156,128.79,1.9558,N/A,24.372,7.4419,N/A,0.83153,357.19,N/A,N/A,N/A,4.5892,N/A,4.9475,10.489,N/A,N/A,1.0404,143.2,10.0085,7.5293,86.7251,N/A,14.931,1.582,6.003,1.4233,7.0963,8.6994,16036.76,3.564,83.3655,1349.08,23.1856,4.6693,1.6983,56.985,1.511,37.144,17.3734,
+2022-01-28,1.1138,128.68,1.9558,N/A,24.443,7.4432,N/A,0.83178,358.42,N/A,N/A,N/A,4.5755,N/A,4.9463,10.552,N/A,N/A,1.0378,144,10.026,7.529,86.6113,N/A,15.1424,1.5971,6.0147,1.4239,7.0857,8.681,16047.76,3.5697,83.6015,1349.47,23.1854,4.6668,1.7031,57.028,1.5109,37.229,17.3844,
+2022-01-27,1.116,128.74,1.9558,N/A,24.427,7.4428,N/A,0.83368,358.09,N/A,N/A,N/A,4.5592,N/A,4.9466,10.445,N/A,N/A,1.0391,145.2,9.9903,7.5328,87.139,N/A,15.1946,1.5771,6.0159,1.4161,7.1061,8.6951,16052.42,3.5695,83.7893,1344.5,23.143,4.6844,1.6872,57.295,1.5089,37.124,17.1112,
+2022-01-26,1.1277,128.86,1.9558,N/A,24.531,7.442,N/A,0.83458,359.67,N/A,N/A,N/A,4.5864,N/A,4.9451,10.4493,N/A,N/A,1.0386,145.6,10.0115,7.529,89.265,N/A,15.2877,1.5727,6.1084,1.4173,7.1293,8.7791,16185.31,3.5834,84.4288,1350.03,23.1845,4.7268,1.6865,57.728,1.5162,37.169,17.0858,
+2022-01-25,1.1268,128.49,1.9558,N/A,24.5,7.4437,N/A,0.83713,359.44,N/A,N/A,N/A,4.5751,N/A,4.9448,10.502,N/A,N/A,1.0364,146,10.1385,7.5295,88.7384,N/A,15.2723,1.5814,6.2049,1.4247,7.1325,8.7725,16169.54,3.5898,84.277,1350.71,23.2909,4.7213,1.6911,57.753,1.5157,37.28,17.2669,
+2022-01-24,1.1304,128.62,1.9558,N/A,24.528,7.4431,N/A,0.83803,359.84,N/A,N/A,N/A,4.5572,N/A,4.9453,10.5038,N/A,N/A,1.0308,145.6,10.1638,7.529,88.649,N/A,15.1621,1.5866,6.1901,1.4269,7.1533,8.8003,16213.69,3.5846,84.3495,1352.41,23.2566,4.7352,1.6901,58.045,1.5216,37.382,17.2509,
+2022-01-21,1.1348,129.14,1.9558,N/A,24.347,7.4431,N/A,0.83633,358.19,N/A,N/A,N/A,4.5318,N/A,4.9453,10.414,N/A,N/A,1.0353,145.6,10.0523,7.528,86.838,N/A,15.223,1.5774,6.2063,1.4211,7.1946,8.837,16244.2,3.5668,84.419,1351.89,23.2229,4.7508,1.6884,58.171,1.526,37.358,17.1546,
+2022-01-20,1.1338,129.53,1.9558,N/A,24.263,7.4424,N/A,0.83265,355.81,N/A,N/A,N/A,4.5228,N/A,4.9453,10.3708,N/A,N/A,1.0382,145.4,9.9578,7.525,86.8952,N/A,15.2094,1.5662,6.1621,1.4158,7.1936,8.8274,16267.5,3.5564,84.362,1349.16,23.1684,4.7489,1.6731,58.285,1.5261,37.319,17.2531,
+2022-01-19,1.1345,129.86,1.9558,N/A,24.313,7.4419,N/A,0.83168,355.88,N/A,N/A,N/A,4.5229,N/A,4.9449,10.3428,N/A,N/A,1.0383,145.2,9.9368,7.5238,86.48,N/A,15.4207,1.5709,6.2657,1.4144,7.2003,8.8392,16283.78,3.5529,84.4135,1347.1,23.0922,4.757,1.6684,58.429,1.5293,37.467,17.3889,
+2022-01-18,1.1367,130.39,1.9558,N/A,24.426,7.4425,N/A,0.83673,357,N/A,N/A,N/A,4.526,N/A,4.9449,10.3185,N/A,N/A,1.0414,146,9.9638,7.5225,86.7325,N/A,15.4447,1.5833,6.2797,1.4228,7.2212,8.8576,16318.64,3.5557,84.813,1355.33,23.1443,4.7554,1.6798,58.553,1.5349,37.635,17.5398,
+2022-01-17,1.1403,130.64,1.9558,N/A,24.467,7.4417,N/A,0.83573,356.09,N/A,N/A,N/A,4.5256,N/A,4.9443,10.305,N/A,N/A,1.0429,146.8,9.9623,7.5275,87.3907,N/A,15.2757,1.5811,6.2808,1.4287,7.2402,8.8844,16337.73,3.5479,84.7295,1359.89,23.1901,4.7704,1.6765,58.496,1.5374,37.761,17.601,
+2022-01-14,1.1447,130.17,1.9558,N/A,24.493,7.4414,N/A,0.83508,356.1,N/A,N/A,N/A,4.5414,N/A,4.9429,10.2684,N/A,N/A,1.0429,147,9.9863,7.5205,88.0011,N/A,15.5256,1.5803,6.3361,1.433,7.2728,8.9119,16388.85,3.5565,84.9445,1361.27,23.2684,4.7831,1.6745,58.727,1.5418,38.033,17.6043,
+2022-01-13,1.1463,130.98,1.9558,N/A,24.458,7.4409,N/A,0.83545,355.24,N/A,N/A,N/A,4.5361,N/A,4.944,10.238,N/A,N/A,1.0453,147,9.9333,7.5202,86.603,N/A,15.5744,1.5709,6.3518,1.4304,7.2913,8.9289,16379.02,3.5638,84.717,1359.24,23.3894,4.7875,1.6676,58.572,1.5427,38.08,17.6381,
+2022-01-12,1.137,131.19,1.9558,N/A,24.423,7.4414,N/A,0.83338,355.98,N/A,N/A,N/A,4.5359,N/A,4.9453,10.264,N/A,N/A,1.0486,147,9.927,7.524,84.7559,N/A,15.5922,1.5762,6.3458,1.4261,7.2379,8.863,16295.93,3.5406,84.0285,1353.27,23.1852,4.7595,1.6775,58.08,1.5358,37.936,17.5645,
+2022-01-11,1.1336,130.95,1.9558,N/A,24.412,7.4404,N/A,0.83475,357.45,N/A,N/A,N/A,4.5438,N/A,4.945,10.3075,N/A,N/A,1.0502,147,10.0165,7.5236,84.8663,N/A,15.696,1.5804,6.389,1.4329,7.2255,8.8384,16221.39,3.549,83.7481,1352.85,23.0888,4.7515,1.6772,57.979,1.5342,37.862,17.7094,
+2022-01-10,1.1318,130.45,1.9558,N/A,24.357,7.4381,N/A,0.83398,358.4,N/A,N/A,N/A,4.5334,N/A,4.9449,10.3038,N/A,N/A,1.0446,146.2,10.0253,7.5278,84.9825,N/A,15.7183,1.5774,6.3969,1.4327,7.2128,8.8233,16181.9,3.5303,83.8,1355.68,23.0597,4.7536,1.6753,58.141,1.5344,38.074,17.6999,
+2022-01-07,1.1298,130.9,1.9558,N/A,24.439,7.438,N/A,0.8343,358.68,N/A,N/A,N/A,4.5496,N/A,4.9451,10.2839,N/A,N/A,1.0422,146,10.0288,7.5214,85.298,N/A,15.7206,1.5804,6.4343,1.4374,7.206,8.8133,16188.43,3.5135,83.978,1359.96,23.1109,4.7553,1.6748,58.046,1.5356,38.074,17.6701,
+2022-01-06,1.1315,131.05,1.9558,N/A,24.528,7.4393,N/A,0.83593,359.84,N/A,N/A,N/A,4.5614,N/A,4.9435,10.3265,N/A,N/A,1.0395,146.8,10.035,7.5197,86.5088,N/A,15.5504,1.5778,6.442,1.4451,7.2187,8.8272,16291.88,3.5247,84.2475,1362.06,23.2549,4.767,1.6752,57.943,1.5388,37.962,17.7932,
+2022-01-05,1.1319,131.03,1.9558,N/A,24.581,7.4384,N/A,0.83546,362.15,N/A,N/A,N/A,4.5666,N/A,4.946,10.2545,N/A,N/A,1.0364,146.8,9.9672,7.519,85.7275,N/A,15.2446,1.56,6.4146,1.4399,7.2087,8.8227,16263.02,3.4989,84.161,1354.61,23.1422,4.7466,1.6597,57.713,1.534,37.607,17.9369,
+2022-01-04,1.1279,131.17,1.9558,N/A,24.745,7.4378,N/A,0.83618,365.12,N/A,N/A,N/A,4.5667,N/A,4.9481,10.2808,N/A,N/A,1.0355,147.8,10.0138,7.5185,84.9202,N/A,15.1384,1.5682,6.4174,1.4382,7.1924,8.7919,16199.73,3.4909,84.2055,1352.91,23.1808,4.7214,1.6668,57.988,1.531,37.582,18.108,
+2022-01-03,1.1355,130.56,1.9558,N/A,24.818,7.4382,N/A,0.84135,367.71,N/A,N/A,N/A,4.5895,N/A,4.9483,10.2958,N/A,N/A,1.0372,147.6,10.0013,7.519,84.5313,N/A,15.0777,1.5691,6.3539,1.442,7.2174,8.8541,16202.02,3.5139,84.3949,1354.4,23.2259,4.7379,1.6651,58.051,1.5333,37.665,17.9661,

ext/csv/types.go

@@ -0,0 +1,52 @@
+package csv
+
+import (
+	"strings"
+
+	"github.com/ncruces/go-sqlite3/util/sql3util"
+)
+
+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 := sql3util.ParseTable(schema)
+	if err != nil {
+		return nil, err
+	}
+
+	columns := tab.Columns
+	types := make([]affinity, len(columns))
+	for i, col := range columns {
+		types[i] = getAffinity(col.Type)
+	}
+	return types, nil
+}
+
+func getAffinity(declType string) affinity {
+	// https://sqlite.org/datatype3.html#determination_of_column_affinity
+	if declType == "" {
+		return blob
+	}
+	name := strings.ToUpper(declType)
+	if strings.Contains(name, "INT") {
+		return integer
+	}
+	if strings.Contains(name, "CHAR") || strings.Contains(name, "CLOB") || strings.Contains(name, "TEXT") {
+		return text
+	}
+	if strings.Contains(name, "BLOB") {
+		return blob
+	}
+	if strings.Contains(name, "REAL") || strings.Contains(name, "FLOA") || strings.Contains(name, "DOUB") {
+		return real
+	}
+	return numeric
+}

ext/csv/types_test.go

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

ext/fileio/coro.go

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

ext/fileio/fileio.go

@@ -0,0 +1,63 @@
+// Package fileio provides SQL functions to read, write and list files.
+//
+// https://sqlite.org/src/doc/tip/ext/misc/fileio.c
+package fileio
+
+import (
+	"errors"
+	"fmt"
+	"io/fs"
+	"os"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+// Register registers SQL functions readfile, writefile, lsmode,
+// and the table-valued function fsdir.
+func Register(db *sqlite3.Conn) error {
+	return RegisterFS(db, nil)
+}
+
+// Register registers SQL functions readfile, lsmode,
+// and the table-valued function fsdir;
+// fsys will be used to read files and list directories.
+func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
+	var err error
+	if fsys == nil {
+		err = db.CreateFunction("writefile", -1, sqlite3.DIRECTONLY, writefile)
+	}
+	return errors.Join(err,
+		db.CreateFunction("readfile", 1, sqlite3.DIRECTONLY, readfile(fsys)),
+		db.CreateFunction("lsmode", 1, sqlite3.DETERMINISTIC, lsmode),
+		sqlite3.CreateModule(db, "fsdir", nil, func(db *sqlite3.Conn, _, _, _ string, _ ...string) (fsdir, error) {
+			err := db.DeclareVTab(`CREATE TABLE x(name,mode,mtime TIMESTAMP,data,path HIDDEN,dir HIDDEN)`)
+			if err == nil {
+				err = db.VTabConfig(sqlite3.VTAB_DIRECTONLY)
+			}
+			return fsdir{fsys}, err
+		}))
+}
+
+func lsmode(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	ctx.ResultText(fs.FileMode(arg[0].Int()).String())
+}
+
+func readfile(fsys fs.FS) func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	return func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+		var err error
+		var data []byte
+
+		if fsys != nil {
+			data, err = fs.ReadFile(fsys, arg[0].Text())
+		} else {
+			data, err = os.ReadFile(arg[0].Text())
+		}
+
+		switch {
+		case err == nil:
+			ctx.ResultBlob(data)
+		case !errors.Is(err, fs.ErrNotExist):
+			ctx.ResultError(fmt.Errorf("readfile: %w", err)) // notest
+		}
+	}
+}

ext/fileio/fileio_test.go

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

ext/fileio/fsdir.go

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

ext/fileio/fsdir_coro.go

@@ -0,0 +1,29 @@
+//go:build !go1.23
+
+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

@@ -0,0 +1,31 @@
+//go:build go1.23
+
+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

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

ext/fileio/write.go

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

ext/fileio/write_test.go

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

ext/hash/blake2.go

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

ext/hash/hash.go

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

ext/hash/hash_test.go

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

ext/hash/sha2.go

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

ext/hash/sha3.go

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

ext/lines/lines.go

@@ -0,0 +1,233 @@
+// Package lines provides a virtual table to read data line-by-line.
+//
+// It is particularly useful for line-oriented datasets,
+// like [ndjson] or [JSON Lines],
+// when paired with SQLite's JSON support.
+//
+// https://github.com/asg017/sqlite-lines
+//
+// [ndjson]: https://ndjson.org/
+// [JSON Lines]: https://jsonlines.org/
+package lines
+
+import (
+	"bufio"
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"io/fs"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/util/osutil"
+)
+
+// Register registers the lines and lines_read table-valued functions.
+// The lines function reads from a database blob or text.
+// The lines_read function reads from a file or an [io.Reader].
+// If a filename is specified, [os.Open] is used to open the file.
+func Register(db *sqlite3.Conn) error {
+	return RegisterFS(db, osutil.FS{})
+}
+
+// RegisterFS registers the lines and lines_read table-valued functions.
+// The lines function reads from a database blob or text.
+// The lines_read function reads from a file or an [io.Reader].
+// If a filename is specified, fsys is used to open the file.
+func RegisterFS(db *sqlite3.Conn, fsys fs.FS) 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, 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, delim HIDDEN)`)
+				if err == nil {
+					err = db.VTabConfig(sqlite3.VTAB_DIRECTONLY)
+				}
+				return lines{fsys}, err
+			}))
+}
+
+type lines struct {
+	fsys fs.FS
+}
+
+func (l lines) BestIndex(idx *sqlite3.IndexInfo) (err error) {
+	err = sqlite3.CONSTRAINT
+	for i, cst := range idx.Constraint {
+		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
+			err = nil
+		case 2:
+			idx.ConstraintUsage[i] = sqlite3.IndexConstraintUsage{
+				Omit:      true,
+				ArgvIndex: 2,
+			}
+		}
+	}
+	return err
+}
+
+func (l lines) Open() (sqlite3.VTabCursor, error) {
+	if l.fsys != nil {
+		return &reader{fsys: l.fsys}, nil
+	} else {
+		return &buffer{}, nil
+	}
+}
+
+type cursor struct {
+	line  []byte
+	rowID int64
+	eof   bool
+	delim byte
+}
+
+func (c *cursor) EOF() bool {
+	return c.eof
+}
+
+func (c *cursor) RowID() (int64, error) {
+	return c.rowID, nil
+}
+
+func (c *cursor) Column(ctx sqlite3.Context, n int) error {
+	if n == 0 {
+		ctx.ResultRawText(c.line)
+	}
+	return nil
+}
+
+type reader struct {
+	fsys   fs.FS
+	reader *bufio.Reader
+	closer io.Closer
+	cursor
+}
+
+func (c *reader) Close() (err error) {
+	if c.closer != nil {
+		err = c.closer.Close()
+		c.closer = nil
+	}
+	return err
+}
+
+func (c *reader) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
+	if err := c.Close(); err != nil {
+		return err
+	}
+
+	var r io.Reader
+	typ := arg[0].Type()
+	switch typ {
+	case sqlite3.NULL:
+		if p, ok := arg[0].Pointer().(io.Reader); ok {
+			r = p
+		}
+	case sqlite3.TEXT:
+		f, err := c.fsys.Open(arg[0].Text())
+		if err != nil {
+			return err
+		}
+		r = f
+	}
+	if r == nil {
+		return fmt.Errorf("lines: unsupported argument:%.0w %v", sqlite3.MISMATCH, typ)
+	}
+
+	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
+	return c.Next()
+}
+
+func (c *reader) Next() (err error) {
+	c.line = c.line[:0]
+	for more := true; more; {
+		var line []byte
+		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 {
+		c.eof = true
+		err = nil
+	}
+	c.rowID++
+	return err
+}
+
+type buffer struct {
+	data []byte
+	cursor
+}
+
+func (c *buffer) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
+	typ := arg[0].Type()
+	switch typ {
+	case sqlite3.TEXT:
+		c.data = arg[0].RawText()
+	case sqlite3.BLOB:
+		c.data = arg[0].RawBlob()
+	default:
+		return fmt.Errorf("lines: unsupported argument:%.0w %v", sqlite3.MISMATCH, typ)
+	}
+
+	c.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, c.delim)
+	j := i + 1
+	switch {
+	case i < 0:
+		i = len(c.data)
+		j = i
+	case i > 0 && c.delim == '\n' && c.data[i-1] == '\r':
+		i--
+	}
+	c.eof = len(c.data) == 0
+	c.line = c.data[:i]
+	c.data = c.data[j:]
+	c.rowID++
+	return nil
+}

ext/lines/lines_test.go

@@ -0,0 +1,183 @@
+package lines_test
+
+import (
+	"database/sql"
+	"errors"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"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"
+)
+
+func Example() {
+	db, err := driver.Open("file:/test.db?vfs=memdb", lines.Register)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	res, err := http.Get("https://storage.googleapis.com/quickdraw_dataset/full/simplified/calendar.ndjson")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer res.Body.Close()
+
+	rows, err := db.Query(`
+		SELECT
+			line ->> '$.countrycode' as countrycode,
+			COUNT(*)
+  		FROM lines_read(?)
+  		GROUP BY 1
+  		ORDER BY 2 DESC
+  		LIMIT 5`,
+		sqlite3.Pointer(res.Body))
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer rows.Close()
+
+	var countrycode sql.RawBytes
+	var count int
+	for rows.Next() {
+		err := rows.Scan(&countrycode, &count)
+		if err != nil {
+			log.Fatal(err)
+		}
+		fmt.Printf("%s: %d\n", countrycode, count)
+	}
+	if err := rows.Err(); err != nil {
+		log.Fatal(err)
+	}
+	// Expected output:
+	// US: 141001
+	// GB: 22560
+	// CA: 11759
+	// RU: 9250
+	// DE: 8748
+}
+
+func Test_lines(t *testing.T) {
+	t.Parallel()
+	tmp := memdb.TestDB(t)
+
+	db, err := driver.Open(tmp, lines.Register)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	const data = "line 1\nline 2\r\nline 3\n"
+
+	rows, err := db.Query(`SELECT rowid, line FROM lines(?)`, data)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var id int64
+		var line string
+		err := rows.Scan(&id, &line)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if want := fmt.Sprintf("line %d", id); line != want {
+			t.Errorf("got %q, want %q", line, want)
+		}
+	}
+}
+
+func Test_lines_error(t *testing.T) {
+	t.Parallel()
+	tmp := memdb.TestDB(t)
+
+	db, err := driver.Open(tmp, lines.Register)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec(`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")
+	if err == nil {
+		t.Fatal("want error")
+	} else {
+		t.Log(err)
+	}
+}
+
+func Test_lines_read(t *testing.T) {
+	t.Parallel()
+	tmp := memdb.TestDB(t)
+
+	db, err := driver.Open(tmp, lines.Register)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	const data = "line 1\nline 2\r\nline 3\n"
+
+	rows, err := db.Query(`SELECT rowid, line FROM lines_read(?)`,
+		sqlite3.Pointer(strings.NewReader(data)))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var id int64
+		var line string
+		err := rows.Scan(&id, &line)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if want := fmt.Sprintf("line %d", id); line != want {
+			t.Errorf("got %q, want %q", line, want)
+		}
+	}
+}
+
+func Test_lines_test(t *testing.T) {
+	t.Parallel()
+	tmp := memdb.TestDB(t)
+
+	db, err := driver.Open(tmp, lines.Register)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer db.Close()
+
+	rows, err := db.Query(`SELECT rowid, line FROM lines_read(?, '}')`, "lines_test.go")
+	if errors.Is(err, os.ErrNotExist) {
+		t.Skip(err)
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var id int64
+		var line string
+		err := rows.Scan(&id, &line)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+}

ext/pivot/op_test.go

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

ext/pivot/pivot.go

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

ext/pivot/pivot_test.go

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

ext/regexp/regexp.go

@@ -0,0 +1,243 @@
+// Package regexp provides additional regular expression functions.
+//
+// It provides the following Unicode aware functions:
+//   - 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.
+//
+// https://github.com/nalgeon/sqlean/blob/main/docs/regexp.md
+package regexp
+
+import (
+	"errors"
+	"regexp"
+	"strings"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+// Register registers Unicode aware functions for a database connection.
+func Register(db *sqlite3.Conn) error {
+	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_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))
+}
+
+// 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(re *regexp.Regexp) string {
+	prefix, complete := re.LiteralPrefix()
+	i := strings.IndexAny(prefix, "*?[")
+	if i < 0 {
+		if complete {
+			return prefix
+		}
+		i = len(prefix)
+	}
+	return prefix[:i] + "*"
+}
+
+func load(ctx sqlite3.Context, i int, expr string) (*regexp.Regexp, error) {
+	re, ok := ctx.GetAuxData(i).(*regexp.Regexp)
+	if !ok {
+		r, err := regexp.Compile(expr)
+		if err != nil {
+			return nil, err
+		}
+		re = r
+		ctx.SetAuxData(0, r)
+	}
+	return re, nil
+}
+
+func regex(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	_ = arg[1] // bounds check
+	re, err := load(ctx, 0, arg[0].Text())
+	if err != nil {
+		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())
+	if err != nil {
+		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, 1, arg[1].Text())
+	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())
+	if err != nil {
+		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, 1, arg[1].Text())
+	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) {
+	_ = arg[2] // bounds check
+
+	re, err := load(ctx, 1, arg[1].Text())
+	if err != nil {
+		ctx.ResultError(err)
+		return // notest
+	}
+
+	text := arg[0].RawText()
+	repl := arg[2].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

@@ -0,0 +1,126 @@
+package regexp
+
+import (
+	"database/sql"
+	"regexp"
+	"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"
+)
+
+func TestRegister(t *testing.T) {
+	t.Parallel()
+	tmp := memdb.TestDB(t)
+
+	db, err := driver.Open(tmp, Register)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	tests := []struct {
+		test string
+		want string
+	}{
+		{`'Hello' REGEXP 'elo'`, "0"},
+		{`'Hello' REGEXP 'ell'`, "1"},
+		{`'Hello' REGEXP 'el.'`, "1"},
+		{`regexp_like('Hello', 'elo')`, "0"},
+		{`regexp_like('Hello', 'ell')`, "1"},
+		{`regexp_like('Hello', 'el.')`, "1"},
+		{`regexp_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://www.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 sql.NullString
+		err := db.QueryRow(`SELECT ` + tt.test).Scan(&got)
+		if err != nil {
+			t.Fatal(err)
+		}
+		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)
+
+	db, err := driver.Open(tmp, Register)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	tests := []string{
+		`'' REGEXP ?`,
+		`regexp_like('', ?)`,
+		`regexp_count('', ?)`,
+		`regexp_instr('', ?)`,
+		`regexp_substr('', ?)`,
+		`regexp_replace('', ?, '')`,
+	}
+
+	for _, tt := range tests {
+		err := db.QueryRow(`SELECT `+tt, `\`).Scan(nil)
+		if err == nil {
+			t.Fatal("want error")
+		}
+	}
+}
+
+func TestGlobPrefix(t *testing.T) {
+	tests := []struct {
+		re   string
+		want string
+	}{
+		{``, ""},
+		{`a`, "a"},
+		{`a*`, "*"},
+		{`a+`, "a*"},
+		{`ab*`, "a*"},
+		{`ab+`, "ab*"},
+		{`a\?b`, "a*"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.re, func(t *testing.T) {
+			if got := GlobPrefix(regexp.MustCompile(tt.re)); got != tt.want {
+				t.Errorf("GlobPrefix() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

ext/serdes/serdes.go

@@ -0,0 +1,136 @@
+// Package serdes provides functions to (de)serialize databases.
+package serdes
+
+import (
+	"io"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/vfs"
+)
+
+func init() {
+	vfs.Register(vfsName, sliceVFS{})
+}
+
+// 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 sliceFile
+	fileToOpen <- &file
+	err := db.Backup(schema, "file:db?vfs="+vfsName)
+	return file.data, 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/ncruces/go-sqlite3/vfs/memdb
+// ["reader"]: https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/readervfs
+func Deserialize(db *sqlite3.Conn, schema string, data []byte) error {
+	fileToOpen <- &sliceFile{data}
+	return db.Restore(schema, "file:db?vfs="+vfsName)
+}
+
+var fileToOpen = make(chan *sliceFile, 1)
+
+const vfsName = "github.com/ncruces/go-sqlite3/ext/deserialize.sliceVFS"
+
+type sliceVFS struct{}
+
+func (sliceVFS) Open(name string, flags vfs.OpenFlag) (vfs.File, vfs.OpenFlag, error) {
+	if flags&vfs.OPEN_MAIN_DB == 0 {
+		// notest // OPEN_MEMORY
+		return nil, flags, sqlite3.CANTOPEN
+	}
+	return <-fileToOpen, flags | vfs.OPEN_MEMORY, nil
+}
+
+func (sliceVFS) Delete(name string, dirSync bool) error {
+	// notest // OPEN_MEMORY
+	return sqlite3.IOERR_DELETE
+}
+
+func (sliceVFS) Access(name string, flag vfs.AccessFlag) (bool, error) {
+	return name == "db", nil
+}
+
+func (sliceVFS) FullPathname(name string) (string, error) {
+	return name, nil
+}
+
+type sliceFile struct{ data []byte }
+
+func (f *sliceFile) ReadAt(b []byte, off int64) (n int, err error) {
+	if d := f.data; off < int64(len(d)) {
+		n = copy(b, d[off:])
+	}
+	if n == 0 {
+		err = io.EOF
+	}
+	return
+}
+
+func (f *sliceFile) WriteAt(b []byte, off int64) (n int, err error) {
+	if d := f.data; off > int64(len(d)) {
+		f.data = append(d, make([]byte, off-int64(len(d)))...)
+	}
+	d := append(f.data[:off], b...)
+	if len(d) > len(f.data) {
+		f.data = d
+	}
+	return len(b), nil
+}
+
+func (f *sliceFile) Size() (int64, error) {
+	return int64(len(f.data)), nil
+}
+
+func (f *sliceFile) Truncate(size int64) error {
+	if d := f.data; size < int64(len(d)) {
+		f.data = d[:size]
+	}
+	return nil
+}
+
+func (f *sliceFile) SizeHint(size int64) error {
+	if d := f.data; size > int64(len(d)) {
+		f.data = append(d, make([]byte, size-int64(len(d)))...)
+	}
+	return nil
+}
+
+func (*sliceFile) Close() error { return nil }
+
+func (*sliceFile) Sync(flag vfs.SyncFlag) error { return nil }
+
+func (*sliceFile) Lock(lock vfs.LockLevel) error { return nil }
+
+func (*sliceFile) Unlock(lock vfs.LockLevel) error { return nil }
+
+func (*sliceFile) CheckReservedLock() (bool, error) {
+	// notest // OPEN_MEMORY
+	return false, nil
+}
+
+func (*sliceFile) SectorSize() int {
+	// notest // IOCAP_POWERSAFE_OVERWRITE
+	return 0
+}
+
+func (*sliceFile) DeviceCharacteristics() vfs.DeviceCharacteristic {
+	return vfs.IOCAP_ATOMIC |
+		vfs.IOCAP_SAFE_APPEND |
+		vfs.IOCAP_SEQUENTIAL |
+		vfs.IOCAP_POWERSAFE_OVERWRITE |
+		vfs.IOCAP_SUBPAGE_READ
+}

ext/serdes/serdes_test.go

@@ -0,0 +1,68 @@
+package serdes_test
+
+import (
+	"io"
+	"net/http"
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+	_ "github.com/ncruces/go-sqlite3/embed"
+	"github.com/ncruces/go-sqlite3/ext/serdes"
+)
+
+func TestDeserialize(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping in short mode")
+	}
+
+	input, err := httpGet()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	db, err := sqlite3.Open(":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)
+	}
+
+	if len(input) != len(output) {
+		t.Fatal("lengths are different")
+	}
+	for i := range input {
+		// 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 input[i] != output[i] {
+			t.Errorf("difference at %d: %d %d", i, input[i], output[i])
+		}
+	}
+}
+
+func httpGet() ([]byte, error) {
+	res, err := http.Get("https://raw.githubusercontent.com/jpwhite3/northwind-SQLite3/refs/heads/main/dist/northwind.db")
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+	return io.ReadAll(res.Body)
+}

ext/statement/stmt.go

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

ext/statement/stmt_test.go

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

ext/stats/TODO.md

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

ext/stats/boolean.go

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

ext/stats/boolean_test.go

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

ext/stats/percentile.go

@@ -0,0 +1,106 @@
+package stats
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"slices"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/ncruces/sort/quick"
+)
+
+const (
+	median = iota
+	percentile_100
+	percentile_cont
+	percentile_disc
+)
+
+func newPercentile(kind int) func() sqlite3.AggregateFunction {
+	return func() sqlite3.AggregateFunction { return &percentile{kind: kind} }
+}
+
+type percentile struct {
+	nums []float64
+	arg1 []byte
+	kind int
+}
+
+func (q *percentile) Step(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	a := arg[0]
+	f := a.Float()
+	if f != 0.0 || a.NumericType() != sqlite3.NULL {
+		q.nums = append(q.nums, f)
+	}
+	if q.kind != median && q.arg1 == nil {
+		q.arg1 = append(q.arg1, arg[1].RawText()...)
+	}
+}
+
+func (q *percentile) Inverse(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	a := arg[0]
+	f := a.Float()
+	if f != 0.0 || a.NumericType() != sqlite3.NULL {
+		i := slices.Index(q.nums, f)
+		l := len(q.nums) - 1
+		q.nums[i] = q.nums[l]
+		q.nums = q.nums[:l]
+	}
+}
+
+func (q *percentile) Value(ctx sqlite3.Context) {
+	if len(q.nums) == 0 {
+		return
+	}
+
+	var (
+		err    error
+		float  float64
+		floats []float64
+	)
+	if q.kind == median {
+		float, err = q.at(0.5)
+		ctx.ResultFloat(float)
+	} else if err = json.Unmarshal(q.arg1, &float); err == nil {
+		float, err = q.at(float)
+		ctx.ResultFloat(float)
+	} else if err = json.Unmarshal(q.arg1, &floats); err == nil {
+		err = q.atMore(floats)
+		ctx.ResultJSON(floats)
+	}
+	if err != nil {
+		ctx.ResultError(fmt.Errorf("percentile: %w", err)) // notest
+	}
+}
+
+func (q *percentile) at(pos float64) (float64, error) {
+	if q.kind == percentile_100 {
+		pos = pos / 100
+	}
+	if pos < 0 || pos > 1 {
+		return 0, util.ErrorString("invalid pos")
+	}
+
+	i, f := math.Modf(pos * float64(len(q.nums)-1))
+	m0 := quick.Select(q.nums, int(i))
+
+	if f == 0 || q.kind == percentile_disc {
+		return m0, nil
+	}
+
+	m1 := slices.Min(q.nums[int(i)+1:])
+	return util.Lerp(m0, m1, f), nil
+}
+
+func (q *percentile) atMore(pos []float64) error {
+	for i := range pos {
+		v, err := q.at(pos[i])
+		if err != nil {
+			return err
+		}
+		pos[i] = v
+	}
+	return nil
+}

ext/stats/percentile_test.go

@@ -0,0 +1,167 @@
+package stats_test
+
+import (
+	"slices"
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+	_ "github.com/ncruces/go-sqlite3/embed"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+)
+
+func TestRegister_percentile(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Exec(`CREATE TABLE data (x)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`INSERT INTO data (x) VALUES (4), (7.0), ('13'), (NULL), (16)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`
+		SELECT
+			median(x),
+			percentile(x, 50),
+			percentile_disc(x, 0.5),
+			percentile_cont(x, '[0.25, 0.5, 0.75]')
+		FROM data`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if stmt.Step() {
+		if got := stmt.ColumnFloat(0); got != 10 {
+			t.Errorf("got %v, want 10", got)
+		}
+		if got := stmt.ColumnFloat(1); got != 10 {
+			t.Errorf("got %v, want 10", got)
+		}
+		if got := stmt.ColumnFloat(2); got != 7 {
+			t.Errorf("got %v, want 7", got)
+		}
+		var got []float64
+		if err := stmt.ColumnJSON(3, &got); err != nil {
+			t.Error(err)
+		}
+		if !slices.Equal(got, []float64{6.25, 10, 13.75}) {
+			t.Errorf("got %v, want [6.25 10 13.75]", got)
+		}
+	}
+	stmt.Close()
+
+	stmt, _, err = db.Prepare(`
+		SELECT
+			median(x) OVER (ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING)
+		FROM data`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if stmt.Step() {
+		if got := stmt.ColumnFloat(0); got != 5.5 {
+			t.Errorf("got %v, want 5.5", got)
+		}
+	}
+	if stmt.Step() {
+		if got := stmt.ColumnFloat(0); got != 7 {
+			t.Errorf("got %v, want 7", got)
+		}
+	}
+	if stmt.Step() {
+		if got := stmt.ColumnFloat(0); got != 10 {
+			t.Errorf("got %v, want 10", got)
+		}
+	}
+	if stmt.Step() {
+		if got := stmt.ColumnFloat(0); got != 14.5 {
+			t.Errorf("got %v, want 14.5", got)
+		}
+	}
+	if stmt.Step() {
+		if got := stmt.ColumnFloat(0); got != 16 {
+			t.Errorf("got %v, want 16", got)
+		}
+	}
+	stmt.Close()
+
+	stmt, _, err = db.Prepare(`
+		SELECT
+			median(x),
+			percentile(x, 50),
+			percentile_disc(x, 0.5),
+			percentile_cont(x, '[0.25, 0.5, 0.75]')
+		FROM data
+		WHERE x < 5`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if stmt.Step() {
+		if got := stmt.ColumnFloat(0); got != 4 {
+			t.Errorf("got %v, want 4", got)
+		}
+		if got := stmt.ColumnFloat(1); got != 4 {
+			t.Errorf("got %v, want 4", got)
+		}
+		if got := stmt.ColumnFloat(2); got != 4 {
+			t.Errorf("got %v, want 4", got)
+		}
+		var got []float64
+		if err := stmt.ColumnJSON(3, &got); err != nil {
+			t.Error(err)
+		}
+		if !slices.Equal(got, []float64{4, 4, 4}) {
+			t.Errorf("got %v, want [4 4 4]", got)
+		}
+	}
+	stmt.Close()
+
+	stmt, _, err = db.Prepare(`
+		SELECT
+			median(x),
+			percentile(x, 50),
+			percentile_disc(x, 0.5),
+			percentile_cont(x, '[0.25, 0.5, 0.75]')
+		FROM data
+		WHERE x < 0`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if stmt.Step() {
+		if got := stmt.ColumnType(0); got != sqlite3.NULL {
+			t.Error("want NULL")
+		}
+		if got := stmt.ColumnType(1); got != sqlite3.NULL {
+			t.Error("want NULL")
+		}
+		if got := stmt.ColumnType(2); got != sqlite3.NULL {
+			t.Error("want NULL")
+		}
+		if got := stmt.ColumnType(3); got != sqlite3.NULL {
+			t.Error("want NULL")
+		}
+	}
+	stmt.Close()
+
+	stmt, _, err = db.Prepare(`
+		SELECT
+			percentile_disc(x, -2),
+			percentile_cont(x, +2),
+			percentile_cont(x, ''),
+			percentile_cont(x, '[100]')
+		FROM data`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if stmt.Step() {
+		t.Error("want error")
+	}
+	stmt.Close()
+}

ext/stats/stats.go

@@ -0,0 +1,205 @@
+// Package stats provides aggregate functions for statistics.
+//
+// Provided functions:
+//   - stddev_pop: population standard deviation
+//   - stddev_samp: sample standard deviation
+//   - var_pop: population variance
+//   - var_samp: sample variance
+//   - covar_pop: population covariance
+//   - covar_samp: sample covariance
+//   - corr: correlation coefficient
+//   - regr_r2: correlation coefficient squared
+//   - regr_avgx: average of the independent variable
+//   - regr_avgy: average of the dependent variable
+//   - regr_sxx: sum of the squares of the independent variable
+//   - regr_syy: sum of the squares of the dependent variable
+//   - regr_sxy: sum of the products of each pair of variables
+//   - regr_count: count non-null pairs of variables
+//   - regr_slope: slope of the least-squares-fit linear equation
+//   - regr_intercept: y-intercept of the least-squares-fit linear equation
+//   - regr_json: all regr stats in a JSON object
+//   - percentile_disc: discrete percentile
+//   - percentile_cont: continuous percentile
+//   - median: median value
+//   - every: boolean and
+//   - some: boolean or
+//
+// These join the [Built-in Aggregate Functions]:
+//   - count: count rows/values
+//   - sum: sum values
+//   - avg: average value
+//   - min: minimum value
+//   - max: maximum value
+//
+// And the [Built-in Window Functions]:
+//   - rank: rank of the current row with gaps
+//   - dense_rank: rank of the current row without gaps
+//   - percent_rank: relative rank of the row
+//   - cume_dist: cumulative distribution
+//
+// See: [ANSI SQL Aggregate Functions]
+//
+// [Built-in Aggregate Functions]: https://sqlite.org/lang_aggfunc.html
+// [Built-in Window Functions]: https://sqlite.org/windowfunctions.html#builtins
+// [ANSI SQL Aggregate Functions]: https://www.oreilly.com/library/view/sql-in-a/9780596155322/ch04s02.html
+package stats
+
+import (
+	"errors"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+// Register registers statistics functions.
+func Register(db *sqlite3.Conn) error {
+	const flags = sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
+	const order = sqlite3.SELFORDER1 | flags
+	return errors.Join(
+		db.CreateWindowFunction("var_pop", 1, flags, newVariance(var_pop)),
+		db.CreateWindowFunction("var_samp", 1, flags, newVariance(var_samp)),
+		db.CreateWindowFunction("stddev_pop", 1, flags, newVariance(stddev_pop)),
+		db.CreateWindowFunction("stddev_samp", 1, flags, newVariance(stddev_samp)),
+		db.CreateWindowFunction("covar_pop", 2, flags, newCovariance(var_pop)),
+		db.CreateWindowFunction("covar_samp", 2, flags, newCovariance(var_samp)),
+		db.CreateWindowFunction("corr", 2, flags, newCovariance(corr)),
+		db.CreateWindowFunction("regr_r2", 2, flags, newCovariance(regr_r2)),
+		db.CreateWindowFunction("regr_sxx", 2, flags, newCovariance(regr_sxx)),
+		db.CreateWindowFunction("regr_syy", 2, flags, newCovariance(regr_syy)),
+		db.CreateWindowFunction("regr_sxy", 2, flags, newCovariance(regr_sxy)),
+		db.CreateWindowFunction("regr_avgx", 2, flags, newCovariance(regr_avgx)),
+		db.CreateWindowFunction("regr_avgy", 2, flags, newCovariance(regr_avgy)),
+		db.CreateWindowFunction("regr_slope", 2, flags, newCovariance(regr_slope)),
+		db.CreateWindowFunction("regr_intercept", 2, flags, newCovariance(regr_intercept)),
+		db.CreateWindowFunction("regr_count", 2, flags, newCovariance(regr_count)),
+		db.CreateWindowFunction("regr_json", 2, flags, newCovariance(regr_json)),
+		db.CreateWindowFunction("median", 1, order, newPercentile(median)),
+		db.CreateWindowFunction("percentile", 2, order, newPercentile(percentile_100)),
+		db.CreateWindowFunction("percentile_cont", 2, order, newPercentile(percentile_cont)),
+		db.CreateWindowFunction("percentile_disc", 2, order, newPercentile(percentile_disc)),
+		db.CreateWindowFunction("every", 1, flags, newBoolean(every)),
+		db.CreateWindowFunction("some", 1, flags, newBoolean(some)))
+}
+
+const (
+	var_pop = iota
+	var_samp
+	stddev_pop
+	stddev_samp
+	corr
+	regr_r2
+	regr_sxx
+	regr_syy
+	regr_sxy
+	regr_avgx
+	regr_avgy
+	regr_slope
+	regr_intercept
+	regr_count
+	regr_json
+)
+
+func newVariance(kind int) func() sqlite3.AggregateFunction {
+	return func() sqlite3.AggregateFunction { return &variance{kind: kind} }
+}
+
+type variance struct {
+	kind int
+	welford
+}
+
+func (fn *variance) Value(ctx sqlite3.Context) {
+	var r float64
+	switch fn.kind {
+	case var_pop:
+		r = fn.var_pop()
+	case var_samp:
+		r = fn.var_samp()
+	case stddev_pop:
+		r = fn.stddev_pop()
+	case stddev_samp:
+		r = fn.stddev_samp()
+	}
+	ctx.ResultFloat(r)
+}
+
+func (fn *variance) Step(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	a := arg[0]
+	f := a.Float()
+	if f != 0.0 || a.NumericType() != sqlite3.NULL {
+		fn.enqueue(f)
+	}
+}
+
+func (fn *variance) Inverse(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	a := arg[0]
+	f := a.Float()
+	if f != 0.0 || a.NumericType() != sqlite3.NULL {
+		fn.dequeue(f)
+	}
+}
+
+func newCovariance(kind int) func() sqlite3.AggregateFunction {
+	return func() sqlite3.AggregateFunction { return &covariance{kind: kind} }
+}
+
+type covariance struct {
+	kind int
+	welford2
+}
+
+func (fn *covariance) Value(ctx sqlite3.Context) {
+	var r float64
+	switch fn.kind {
+	case var_pop:
+		r = fn.covar_pop()
+	case var_samp:
+		r = fn.covar_samp()
+	case corr:
+		r = fn.correlation()
+	case regr_r2:
+		r = fn.regr_r2()
+	case regr_sxx:
+		r = fn.regr_sxx()
+	case regr_syy:
+		r = fn.regr_syy()
+	case regr_sxy:
+		r = fn.regr_sxy()
+	case regr_avgx:
+		r = fn.regr_avgx()
+	case regr_avgy:
+		r = fn.regr_avgy()
+	case regr_slope:
+		r = fn.regr_slope()
+	case regr_intercept:
+		r = fn.regr_intercept()
+	case regr_count:
+		ctx.ResultInt64(fn.regr_count())
+		return
+	case regr_json:
+		ctx.ResultText(fn.regr_json())
+		return
+	}
+	ctx.ResultFloat(r)
+}
+
+func (fn *covariance) Step(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	b, a := arg[1], arg[0] // avoid a bounds check
+	fa := a.Float()
+	fb := b.Float()
+	if true &&
+		(fa != 0.0 || a.NumericType() != sqlite3.NULL) &&
+		(fb != 0.0 || b.NumericType() != sqlite3.NULL) {
+		fn.enqueue(fa, fb)
+	}
+}
+
+func (fn *covariance) Inverse(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	b, a := arg[1], arg[0] // avoid a bounds check
+	fa := a.Float()
+	fb := b.Float()
+	if true &&
+		(fa != 0.0 || a.NumericType() != sqlite3.NULL) &&
+		(fb != 0.0 || b.NumericType() != sqlite3.NULL) {
+		fn.dequeue(fa, fb)
+	}
+}

ext/stats/stats_test.go

@@ -0,0 +1,243 @@
+package stats_test
+
+import (
+	"math"
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+	_ "github.com/ncruces/go-sqlite3/embed"
+	"github.com/ncruces/go-sqlite3/ext/stats"
+	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
+)
+
+func TestMain(m *testing.M) {
+	sqlite3.AutoExtension(stats.Register)
+	m.Run()
+}
+
+func TestRegister_variance(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Exec(`CREATE TABLE data (x)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`INSERT INTO data (x) VALUES (4), (7.0), ('13'), (NULL), (16)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`
+		SELECT
+			sum(x), avg(x),
+			var_samp(x), var_pop(x),
+			stddev_samp(x), stddev_pop(x)
+		FROM data`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if stmt.Step() {
+		if got := stmt.ColumnFloat(0); got != 40 {
+			t.Errorf("got %v, want 40", got)
+		}
+		if got := stmt.ColumnFloat(1); got != 10 {
+			t.Errorf("got %v, want 10", got)
+		}
+		if got := stmt.ColumnFloat(2); got != 30 {
+			t.Errorf("got %v, want 30", got)
+		}
+		if got := stmt.ColumnFloat(3); got != 22.5 {
+			t.Errorf("got %v, want 22.5", got)
+		}
+		if got := stmt.ColumnFloat(4); got != math.Sqrt(30) {
+			t.Errorf("got %v, want √30", got)
+		}
+		if got := stmt.ColumnFloat(5); got != math.Sqrt(22.5) {
+			t.Errorf("got %v, want √22.5", got)
+		}
+	}
+	stmt.Close()
+
+	stmt, _, err = db.Prepare(`SELECT var_samp(x) OVER (ROWS 1 PRECEDING) FROM data`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want := [...]float64{0, 4.5, 18, 0, 0}
+	for i := 0; stmt.Step(); i++ {
+		if got := stmt.ColumnFloat(0); got != want[i] {
+			t.Errorf("got %v, want %v", got, want[i])
+		}
+		if got := stmt.ColumnType(0); (got == sqlite3.FLOAT) != (want[i] != 0) {
+			t.Errorf("got %v, want %v", got, want[i])
+		}
+	}
+	stmt.Close()
+}
+
+func TestRegister_covariance(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.Exec(`CREATE TABLE data (y, x)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`INSERT INTO data (y, x) VALUES (3, 70), (5, 80), (2, 60), (7, 90), (4, 75)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmt, _, err := db.Prepare(`SELECT
+		corr(y, x), covar_samp(y, x), covar_pop(y, x),
+		regr_avgy(y, x), regr_avgx(y, x),
+		regr_syy(y, x), regr_sxx(y, x), regr_sxy(y, x),
+		regr_slope(y, x), regr_intercept(y, x), regr_r2(y, x),
+		regr_count(y, x), regr_json(y, x)
+		FROM data`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if stmt.Step() {
+		if got := stmt.ColumnFloat(0); got != 0.9881049293224639 {
+			t.Errorf("got %v, want 0.9881049293224639", got)
+		}
+		if got := stmt.ColumnFloat(1); got != 21.25 {
+			t.Errorf("got %v, want 21.25", got)
+		}
+		if got := stmt.ColumnFloat(2); got != 17 {
+			t.Errorf("got %v, want 17", got)
+		}
+		if got := stmt.ColumnFloat(3); got != 4.2 {
+			t.Errorf("got %v, want 4.2", got)
+		}
+		if got := stmt.ColumnFloat(4); got != 75 {
+			t.Errorf("got %v, want 75", got)
+		}
+		if got := stmt.ColumnFloat(5); got != 14.8 {
+			t.Errorf("got %v, want 14.8", got)
+		}
+		if got := stmt.ColumnFloat(6); got != 500 {
+			t.Errorf("got %v, want 500", got)
+		}
+		if got := stmt.ColumnFloat(7); got != 85 {
+			t.Errorf("got %v, want 85", got)
+		}
+		if got := stmt.ColumnFloat(8); got != 0.17 {
+			t.Errorf("got %v, want 0.17", got)
+		}
+		if got := stmt.ColumnFloat(9); got != -8.55 {
+			t.Errorf("got %v, want -8.55", got)
+		}
+		if got := stmt.ColumnFloat(10); got != 0.9763513513513513 {
+			t.Errorf("got %v, want 0.9763513513513513", got)
+		}
+		if got := stmt.ColumnInt(11); got != 5 {
+			t.Errorf("got %v, want 5", got)
+		}
+		var a map[string]float64
+		if err := stmt.ColumnJSON(12, &a); err != nil {
+			t.Error(err)
+		} else if got := a["count"]; got != 5 {
+			t.Errorf("got %v, want 5", got)
+		}
+	}
+	stmt.Close()
+
+	stmt, _, err = db.Prepare(`SELECT covar_samp(y, x) OVER (ROWS 1 PRECEDING) FROM data`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want := [...]float64{0, 10, 30, 75, 22.5}
+	for i := 0; stmt.Step(); i++ {
+		if got := stmt.ColumnFloat(0); got != want[i] {
+			t.Errorf("got %v, want %v", got, want[i])
+		}
+		if got := stmt.ColumnType(0); (got == sqlite3.FLOAT) != (want[i] != 0) {
+			t.Errorf("got %v, want %v", got, want[i])
+		}
+	}
+	stmt.Close()
+}
+
+func Benchmark_average(b *testing.B) {
+	sqlite3.Initialize()
+	b.ResetTimer()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer db.Close()
+
+	stmt, _, err := db.Prepare(`SELECT avg(value) FROM generate_series(0, ?)`)
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer stmt.Close()
+
+	err = stmt.BindInt(1, b.N)
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	if stmt.Step() {
+		want := float64(b.N) / 2
+		if got := stmt.ColumnFloat(0); got != want {
+			b.Errorf("got %v, want %v", got, want)
+		}
+	}
+
+	err = stmt.Err()
+	if err != nil {
+		b.Error(err)
+	}
+}
+
+func Benchmark_variance(b *testing.B) {
+	sqlite3.Initialize()
+	b.ResetTimer()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer db.Close()
+
+	stmt, _, err := db.Prepare(`SELECT var_pop(value) FROM generate_series(0, ?)`)
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer stmt.Close()
+
+	err = stmt.BindInt(1, b.N)
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	if stmt.Step() && b.N > 100 {
+		want := float64(b.N*b.N) / 12
+		if got := stmt.ColumnFloat(0); want > (got-want)*float64(b.N) {
+			b.Errorf("got %v, want %v", got, want)
+		}
+	}
+
+	err = stmt.Err()
+	if err != nil {
+		b.Error(err)
+	}
+}

ext/stats/welford.go

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

ext/stats/welford_test.go

@@ -0,0 +1,81 @@
+package stats
+
+import (
+	"math"
+	"testing"
+)
+
+func Test_welford(t *testing.T) {
+	t.Parallel()
+
+	var s1, s2 welford
+
+	s1.enqueue(4)
+	s1.enqueue(7)
+	s1.enqueue(13)
+	s1.enqueue(16)
+	if got := s1.average(); got != 10 {
+		t.Errorf("got %v, want 10", got)
+	}
+	if got := s1.var_samp(); got != 30 {
+		t.Errorf("got %v, want 30", got)
+	}
+	if got := s1.var_pop(); got != 22.5 {
+		t.Errorf("got %v, want 22.5", got)
+	}
+	if got := s1.stddev_samp(); got != math.Sqrt(30) {
+		t.Errorf("got %v, want √30", got)
+	}
+	if got := s1.stddev_pop(); got != math.Sqrt(22.5) {
+		t.Errorf("got %v, want √22.5", got)
+	}
+
+	s1.dequeue(4)
+	s2.enqueue(7)
+	s2.enqueue(13)
+	s2.enqueue(16)
+	if s1.var_pop() != s2.var_pop() {
+		t.Errorf("got %v, want %v", s1, s2)
+	}
+}
+
+func Test_covar(t *testing.T) {
+	t.Parallel()
+
+	var c1, c2 welford2
+
+	c1.enqueue(3, 70)
+	c1.enqueue(5, 80)
+	c1.enqueue(2, 60)
+	c1.enqueue(7, 90)
+	c1.enqueue(4, 75)
+
+	if got := c1.covar_samp(); got != 21.25 {
+		t.Errorf("got %v, want 21.25", got)
+	}
+	if got := c1.covar_pop(); got != 17 {
+		t.Errorf("got %v, want 17", got)
+	}
+
+	c1.dequeue(3, 70)
+	c2.enqueue(5, 80)
+	c2.enqueue(2, 60)
+	c2.enqueue(7, 90)
+	c2.enqueue(4, 75)
+	if c1.covar_pop() != c2.covar_pop() {
+		t.Errorf("got %v, want %v", c1.covar_pop(), c2.covar_pop())
+	}
+}
+
+func Test_correlation(t *testing.T) {
+	t.Parallel()
+
+	var c welford2
+	c.enqueue(1, 3)
+	c.enqueue(2, 2)
+	c.enqueue(3, 1)
+
+	if got := c.correlation(); got != -1 {
+		t.Errorf("got %v, want -1", got)
+	}
+}

ext/unicode/unicode.go

@@ -0,0 +1,244 @@
+// Package unicode provides an alternative to the SQLite ICU extension.
+//
+// Like the [ICU extension], it provides Unicode aware:
+//   - upper() and lower() functions,
+//   - LIKE and REGEXP operators,
+//   - collation sequences.
+//
+// It also provides, from PostgreSQL:
+//   - unaccent(),
+//   - initcap().
+//
+// The implementation is not 100% compatible with the [ICU extension]:
+//   - upper() and lower() use [strings.ToUpper], [strings.ToLower] and [cases];
+//   - the LIKE operator follows [strings.EqualFold] rules;
+//   - the REGEXP operator uses Go [regexp/syntax];
+//   - collation sequences use [collate].
+//
+// Expect subtle differences (e.g.) in the handling of Turkish case folding.
+//
+// [ICU extension]: https://sqlite.org/src/dir/ext/icu
+package unicode
+
+import (
+	"bytes"
+	"errors"
+	"regexp"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+
+	"golang.org/x/text/cases"
+	"golang.org/x/text/collate"
+	"golang.org/x/text/language"
+	"golang.org/x/text/runes"
+	"golang.org/x/text/transform"
+	"golang.org/x/text/unicode/norm"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
+)
+
+// Set RegisterLike to false to not register a Unicode aware LIKE operator.
+// Overriding the built-in LIKE operator disables the [LIKE optimization].
+//
+// [LIKE optimization]: https://sqlite.org/optoverview.html#the_like_optimization
+var RegisterLike = true
+
+// Register registers Unicode aware functions for a database connection.
+func Register(db *sqlite3.Conn) error {
+	const flags = sqlite3.DETERMINISTIC | sqlite3.INNOCUOUS
+	var errs util.ErrorJoiner
+	if RegisterLike {
+		errs.Join(
+			db.CreateFunction("like", 2, flags, like),
+			db.CreateFunction("like", 3, flags, like))
+	}
+	errs.Join(
+		db.CreateFunction("upper", 1, flags, upper),
+		db.CreateFunction("upper", 2, flags, upper),
+		db.CreateFunction("lower", 1, flags, lower),
+		db.CreateFunction("lower", 2, flags, lower),
+		db.CreateFunction("regexp", 2, flags, regex),
+		db.CreateFunction("initcap", 1, flags, initcap),
+		db.CreateFunction("initcap", 2, flags, initcap),
+		db.CreateFunction("unaccent", 1, flags, unaccent),
+		db.CreateFunction("icu_load_collation", 2, sqlite3.DIRECTONLY,
+			func(ctx sqlite3.Context, arg ...sqlite3.Value) {
+				name := arg[1].Text()
+				if name == "" {
+					return
+				}
+
+				err := RegisterCollation(ctx.Conn(), arg[0].Text(), name)
+				if err != nil {
+					ctx.ResultError(err)
+					return // notest
+				}
+			}))
+	return errors.Join(errs...)
+}
+
+// RegisterCollation registers a Unicode collation sequence for a database connection.
+func RegisterCollation(db *sqlite3.Conn, locale, name string) error {
+	tag, err := language.Parse(locale)
+	if err != nil {
+		return err
+	}
+	return db.CreateCollation(name, collate.New(tag).Compare)
+}
+
+// RegisterCollationsNeeded registers Unicode collation sequences on demand for a database connection.
+func RegisterCollationsNeeded(db *sqlite3.Conn) error {
+	return db.CollationNeeded(func(db *sqlite3.Conn, name string) {
+		if tag, err := language.Parse(name); err == nil {
+			db.CreateCollation(name, collate.New(tag).Compare)
+		}
+	})
+}
+
+func upper(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	if len(arg) == 1 {
+		ctx.ResultRawText(bytes.ToUpper(arg[0].RawText()))
+		return
+	}
+	cs, ok := ctx.GetAuxData(1).(cases.Caser)
+	if !ok {
+		t, err := language.Parse(arg[1].Text())
+		if err != nil {
+			ctx.ResultError(err)
+			return // notest
+		}
+		c := cases.Upper(t)
+		ctx.SetAuxData(1, c)
+		cs = c
+	}
+	ctx.ResultRawText(cs.Bytes(arg[0].RawText()))
+}
+
+func lower(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	if len(arg) == 1 {
+		ctx.ResultRawText(bytes.ToLower(arg[0].RawText()))
+		return
+	}
+	cs, ok := ctx.GetAuxData(1).(cases.Caser)
+	if !ok {
+		t, err := language.Parse(arg[1].Text())
+		if err != nil {
+			ctx.ResultError(err)
+			return // notest
+		}
+		c := cases.Lower(t)
+		ctx.SetAuxData(1, c)
+		cs = c
+	}
+	ctx.ResultRawText(cs.Bytes(arg[0].RawText()))
+}
+
+func initcap(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	if len(arg) == 1 {
+		ctx.ResultRawText(bytes.Title(arg[0].RawText()))
+		return
+	}
+	cs, ok := ctx.GetAuxData(1).(cases.Caser)
+	if !ok {
+		t, err := language.Parse(arg[1].Text())
+		if err != nil {
+			ctx.ResultError(err)
+			return // notest
+		}
+		c := cases.Title(t)
+		ctx.SetAuxData(1, c)
+		cs = c
+	}
+	ctx.ResultRawText(cs.Bytes(arg[0].RawText()))
+}
+
+func unaccent(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	unaccent := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
+	res, _, err := transform.Bytes(unaccent, arg[0].RawText())
+	if err != nil {
+		ctx.ResultError(err) // notest
+	} else {
+		ctx.ResultRawText(res)
+	}
+}
+
+func regex(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	re, ok := ctx.GetAuxData(0).(*regexp.Regexp)
+	if !ok {
+		r, err := regexp.Compile(arg[0].Text())
+		if err != nil {
+			ctx.ResultError(err)
+			return // notest
+		}
+		re = r
+		ctx.SetAuxData(0, r)
+	}
+	ctx.ResultBool(re.Match(arg[1].RawText()))
+}
+
+func like(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	escape := rune(-1)
+	if len(arg) == 3 {
+		var size int
+		b := arg[2].RawText()
+		escape, size = utf8.DecodeRune(b)
+		if size != len(b) {
+			ctx.ResultError(util.ErrorString("ESCAPE expression must be a single character"))
+			return
+		}
+	}
+	_ = arg[1] // bounds check
+
+	type likeData struct {
+		*regexp.Regexp
+		escape rune
+	}
+
+	re, ok := ctx.GetAuxData(0).(likeData)
+	if !ok || re.escape != escape {
+		re = likeData{
+			regexp.MustCompile(like2regex(arg[0].Text(), escape)),
+			escape,
+		}
+		ctx.SetAuxData(0, re)
+	}
+	ctx.ResultBool(re.Match(arg[1].RawText()))
+}
+
+func like2regex(pattern string, escape rune) string {
+	var re strings.Builder
+	start := 0
+	literal := false
+	re.Grow(len(pattern) + 10)
+	re.WriteString(`(?is)\A`) // case insensitive, . matches any character
+	for i, r := range pattern {
+		if start < 0 {
+			start = i
+		}
+		if literal {
+			literal = false
+			continue
+		}
+		var symbol string
+		switch r {
+		case '_':
+			symbol = `.`
+		case '%':
+			symbol = `.*`
+		case escape:
+			literal = true
+		default:
+			continue
+		}
+		re.WriteString(regexp.QuoteMeta(pattern[start:i]))
+		re.WriteString(symbol)
+		start = -1
+	}
+	if start >= 0 {
+		re.WriteString(regexp.QuoteMeta(pattern[start:]))
+	}
+	re.WriteString(`\z`)
+	return re.String()
+}