SQLite 3.48.0.

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

.github/actions/lfs/action.yml

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

.github/actions/vmactions/template.yml

@@ -0,0 +1,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/workflows/build-test.sh

@@ -6,6 +6,10 @@ echo 'set -eu' > test.sh
 for p in $(go list ./...); do
   dir=".${p#github.com/ncruces/go-sqlite3}"
   name="$(basename "$p").test"
-  (cd ${dir}; go test -c)
-  [ -f "${dir}/${name}" ] && echo "(cd ${dir}; ./${name} ${TESTFLAGS})" >> test.sh
-done
+  (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/cross.sh

@@ -1,27 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-echo android       ; GOOS=android   GOARCH=amd64 go build .
-echo darwin        ; GOOS=darwin    GOARCH=amd64 go build .
-echo dragonfly     ; GOOS=dragonfly GOARCH=amd64 go build .
-echo freebsd       ; GOOS=freebsd   GOARCH=amd64 go build .
-echo illumos       ; GOOS=illumos   GOARCH=amd64 go build .
-echo ios           ; GOOS=ios       GOARCH=amd64 go build .
-echo linux         ; GOOS=linux     GOARCH=amd64 go build .
-echo netbsd        ; GOOS=netbsd    GOARCH=amd64 go build .
-echo openbsd       ; GOOS=openbsd   GOARCH=amd64 go build .
-echo plan9         ; GOOS=plan9     GOARCH=amd64 go build .
-echo solaris       ; GOOS=solaris   GOARCH=amd64 go build .
-echo windows       ; GOOS=windows   GOARCH=amd64 go build .
-echo aix           ; GOOS=aix       GOARCH=ppc64 go build .
-echo js            ; GOOS=js        GOARCH=wasm  go build .
-echo wasip1        ; GOOS=wasip1    GOARCH=wasm  go build .
-echo linux-flock   ; GOOS=linux     GOARCH=amd64 go build -tags sqlite3_flock .
-echo linux-noshm   ; GOOS=linux     GOARCH=amd64 go build -tags sqlite3_noshm .
-echo linux-nosys   ; GOOS=linux     GOARCH=amd64 go build -tags sqlite3_nosys .
-echo darwin-flock  ; GOOS=darwin    GOARCH=amd64 go build -tags sqlite3_flock .
-echo darwin-noshm  ; GOOS=darwin    GOARCH=amd64 go build -tags sqlite3_noshm .
-echo darwin-nosys  ; GOOS=darwin    GOARCH=amd64 go build -tags sqlite3_nosys .
-echo windows-nosys ; GOOS=windows   GOARCH=amd64 go build -tags sqlite3_nosys .
-echo freebsd-nosys ; GOOS=freebsd   GOARCH=amd64 go build -tags sqlite3_nosys .
-echo solaris-flock ; GOOS=solaris   GOARCH=amd64 go build -tags sqlite3_flock .

.github/workflows/cross.yml

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

.github/workflows/repro.sh

@@ -2,14 +2,14 @@
 set -euo pipefail
 
 if [[ "$OSTYPE" == "linux"* ]]; then
-  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-24/wasi-sdk-24.0-x86_64-linux.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_119/binaryen-version_119-x86_64-linux.tar.gz"
+  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-24/wasi-sdk-24.0-x86_64-macos.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_119/binaryen-version_119-x86_64-macos.tar.gz"
+  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-24/wasi-sdk-24.0-x86_64-windows.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_119/binaryen-version_119-x86_64-windows.tar.gz"
+  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
@@ -27,8 +27,8 @@ embed/build.sh
 embed/bcw2/build.sh
 
 # Download and build sqlite-createtable-parser
-util/vtabutil/parse/download.sh
-util/vtabutil/parse/build.sh
+util/sql3util/wasm/download.sh
+util/sql3util/wasm/build.sh
 
 # Check diffs
 git diff --exit-code

.github/workflows/repro.yml

@@ -18,17 +18,15 @@ jobs:
     steps:
     - uses: ilammy/msvc-dev-cmd@v1
     - uses: actions/checkout@v4
-    - uses: actions/setup-go@v5
-      with: { go-version: stable }
 
     - name: Build
       shell: bash
       run: .github/workflows/repro.sh
 
-    - uses: actions/attest-build-provenance@v1
+    - uses: actions/attest-build-provenance@v2
       if: matrix.os == 'ubuntu-latest'
       with:
         subject-path: |
           embed/sqlite3.wasm
           embed/bcw2/bcw2.wasm
-          util/vtabutil/parse/sql3parse_table.wasm
+          util/sql3util/wasm/sql3parse_table.wasm

.github/workflows/test.yml

@@ -2,9 +2,17 @@ name: Test
 
 on:
   push:
-    branches: [ "main" ]
+    branches: [ 'main' ]
+    paths:
+      - '**.go'
+      - '**.mod'
+      - '**.wasm'
   pull_request:
-    branches: [ "main" ]
+    branches: [ 'main' ]
+    paths:
+      - '**.go'
+      - '**.mod'
+      - '**.wasm'
   workflow_dispatch:
 
 jobs:
@@ -19,9 +27,6 @@ jobs:
     - uses: actions/setup-go@v5
       with: { go-version: stable }
 
-    - name: Git LFS pull
-      uses: ./.github/actions/lfs
-
     - name: Format
       run: gofmt -s -w . && git diff --exit-code
       if: matrix.os != 'windows-latest'
@@ -46,24 +51,22 @@ jobs:
 
     - name: Test BSD locks
       run: go test -v -tags sqlite3_flock ./...
-      if: matrix.os == 'macos-latest'
+      if: matrix.os != 'windows-latest'
 
-    - name: Test no shared memory
-      run: go test -v -tags sqlite3_noshm ./...
-      if: matrix.os == 'ubuntu-latest'
-
-    - name: Test no locks
-      run: go test -v -tags sqlite3_nosys ./...
-      if: matrix.os == 'ubuntu-latest'
+    - name: Test 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 install github.com/dave/courtney@latest
-        courtney
+      run: go run github.com/dave/courtney@latest
       if: |
         github.event_name == 'push' &&
         matrix.os == 'ubuntu-latest'
@@ -77,60 +80,106 @@ jobs:
         github.event_name == 'push' &&
         matrix.os == 'ubuntu-latest'
 
-  test-intel:
-    runs-on: macos-13
-    needs: test
-
-    steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-go@v5
-      with: { go-version: stable }
-
-    - name: Git LFS pull
-      uses: ./.github/actions/lfs
-
-    - name: Test
-      run: go test -v ./...
-
   test-bsd:
     strategy:
       matrix:
         os:
           - name: freebsd
-            version: '14.1'
+            version: '14.2'
             flags: '-test.v'
-          - name: openbsd
-            version: '7.5'
-            flags: '-test.v -test.short'
           - 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
-    - uses: actions/setup-go@v5
-      with: { go-version: stable }
-
-    - name: Git LFS pull
-      uses: ./.github/actions/lfs
 
     - 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.25.0
+      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
@@ -141,9 +190,6 @@ jobs:
     - uses: actions/setup-go@v5
       with: { go-version: stable }
 
-    - name: Git LFS pull
-      uses: ./.github/actions/lfs
-
     - name: Test 386 (32-bit)
       run: GOARCH=386 go test -v -short ./...
 
@@ -156,11 +202,11 @@ jobs:
     - name: Test ppc64le (interpreter)
       run: GOARCH=ppc64le go test -v -short ./...
 
-    - name: Test s390x (big-endian, z/OS demo)
-      run: GOARCH=s390x go test -v -short -tags sqlite3_flock ./...
+    - name: Test s390x (big-endian)
+      run: GOARCH=s390x go test -v -short -tags sqlite3_dotlk ./...
 
-  test-vm:
-    runs-on: ubuntu-latest
+  test-macintel:
+    runs-on: macos-13
     needs: test
 
     steps:
@@ -168,32 +214,5 @@ jobs:
     - uses: actions/setup-go@v5
       with: { go-version: stable }
 
-    - name: Git LFS pull
-      uses: ./.github/actions/lfs
-
-    - name: Build illumos
-      env:
-        GOOS: illumos
-        TESTFLAGS: '-test.v -test.short'
-      run: .github/workflows/build-test.sh
-
-    - name: Test illumos
-      uses: vmactions/omnios-vm@v1
-      with:
-        usesh: true
-        copyback: false
-        run: . ./test.sh
-
-    - name: Build Solaris
-      env:
-        GOOS: solaris
-        TESTFLAGS: '-test.v -test.short'
-      run: .github/workflows/build-test.sh
-
-    - name: Test Solaris
-      uses: vmactions/solaris-vm@v1
-      with:
-        usesh: true
-        copyback: false
-        run: . ./test.sh
-      continue-on-error: true
+    - name: Test
+      run: go test -v ./...

README.md

@@ -1,4 +1,4 @@
-# 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)
@@ -10,7 +10,7 @@ as well as direct access to most of the [C SQLite API](https://sqlite.org/cintro
 
 It wraps a [Wasm](https://webassembly.org/) [build](embed/) of SQLite,
 and uses [wazero](https://wazero.io/) as the runtime.\
-Go, wazero and [`x/sys`](https://pkg.go.dev/golang.org/x/sys) are the _only_ runtime dependencies.
+Go, wazero and [`x/sys`](https://pkg.go.dev/golang.org/x/sys) are the _only_ direct dependencies.
 
 ### Getting started
 
@@ -41,45 +41,6 @@ db.QueryRow(`SELECT sqlite_version()`).Scan(&version)
 - [`github.com/ncruces/go-sqlite3/gormlite`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/gormlite)
   provides a [GORM](https://gorm.io) driver.
 
-### Extensions
-
-- [`github.com/ncruces/go-sqlite3/ext/array`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/array)
-  provides the [`array`](https://sqlite.org/carray.html) table-valued function.
-- [`github.com/ncruces/go-sqlite3/ext/blobio`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/blobio)
-  simplifies [incremental BLOB I/O](https://sqlite.org/c3ref/blob_open.html).
-- [`github.com/ncruces/go-sqlite3/ext/bloom`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/bloom)
-  provides a [Bloom filter](https://github.com/nalgeon/sqlean/issues/27#issuecomment-1002267134) virtual table.
-- [`github.com/ncruces/go-sqlite3/ext/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.
-- [`github.com/ncruces/go-sqlite3/vfs/adiantum`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/adiantum)
-  wraps a VFS to offer encryption at rest.
-- [`github.com/ncruces/go-sqlite3/vfs/memdb`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/memdb)
-  implements an in-memory VFS.
-- [`github.com/ncruces/go-sqlite3/vfs/readervfs`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/readervfs)
-  implements a VFS for immutable databases.
-
 ### Advanced features
 
 - [incremental BLOB I/O](https://sqlite.org/c3ref/blob_open.html)
@@ -92,7 +53,11 @@ db.QueryRow(`SELECT sqlite_version()`).Scan(&version)
 - [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
@@ -109,10 +74,10 @@ This project aims for [high test coverage](https://github.com/ncruces/go-sqlite3
 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.
 
-Every commit is [tested](https://github.com/ncruces/go-sqlite3/wiki/Test-matrix) on
+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), OpenBSD (amd64), NetBSD (amd64),
-illumos (amd64), and Solaris (amd64).
+Windows (amd64), FreeBSD (amd64/arm64), OpenBSD (amd64), NetBSD (amd64/arm64),
+DragonFly BSD (amd64), illumos (amd64), and Solaris (amd64).
 
 The Go VFS is tested by running SQLite's
 [mptest](https://github.com/sqlite/sqlite/blob/master/mptest/mptest.c).
@@ -125,9 +90,20 @@ Perfomance of the [`database/sql`](https://pkg.go.dev/database/sql) driver is
 The Wasm and VFS layers are also tested by running SQLite's
 [speedtest1](https://github.com/sqlite/sqlite/blob/master/test/speedtest1.c).
 
+### FAQ, issues, new features
+
+For questions, please see [Discussions](https://github.com/ncruces/go-sqlite3/discussions/categories/q-a).
+
+Also, post there if you used this driver for something interesting
+([_"Show and tell"_](https://github.com/ncruces/go-sqlite3/discussions/categories/show-and-tell)),
+have an [idea](https://github.com/ncruces/go-sqlite3/discussions/categories/ideas)…
+
+The [Issue](https://github.com/ncruces/go-sqlite3/issues) tracker is for bugs 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)

blob.go

@@ -253,6 +253,7 @@ func (b *Blob) Seek(offset int64, whence int) (int64, error) {
 //
 // https://sqlite.org/c3ref/blob_reopen.html
 func (b *Blob) Reopen(row int64) error {
+	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

config.go

@@ -2,10 +2,13 @@ package sqlite3
 
 import (
 	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/tetratelabs/wazero/api"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
 	"github.com/ncruces/go-sqlite3/vfs"
-	"github.com/tetratelabs/wazero/api"
 )
 
 // Config makes configuration changes to a database connection.
@@ -15,8 +18,19 @@ import (
 //
 // 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(2 * ptrlen)
+	argsPtr := c.arena.new(intlen + ptrlen)
 
 	var flag int
 	switch {
@@ -57,24 +71,38 @@ func logCallback(ctx context.Context, mod api.Module, _, iCode, zMsg uint32) {
 	}
 }
 
+// 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:
-		r := c.call("sqlite3_file_control",
+		rc = c.call("sqlite3_file_control",
 			uint64(c.handle), uint64(schemaPtr),
 			uint64(op), 0)
-		return nil, c.error(r)
 
 	case FCNTL_PERSIST_WAL, FCNTL_POWERSAFE_OVERWRITE:
 		var flag int
@@ -84,70 +112,69 @@ func (c *Conn) FileControl(schema string, op FcntlOpcode, arg ...any) (any, erro
 		case arg[0]:
 			flag = 1
 		}
-		ptr := c.arena.new(4)
 		util.WriteUint32(c.mod, ptr, uint32(flag))
-		r := c.call("sqlite3_file_control",
+		rc = c.call("sqlite3_file_control",
 			uint64(c.handle), uint64(schemaPtr),
 			uint64(op), uint64(ptr))
-		return util.ReadUint32(c.mod, ptr) != 0, c.error(r)
+		res = util.ReadUint32(c.mod, ptr) != 0
 
 	case FCNTL_CHUNK_SIZE:
-		ptr := c.arena.new(4)
 		util.WriteUint32(c.mod, ptr, uint32(arg[0].(int)))
-		r := c.call("sqlite3_file_control",
+		rc = c.call("sqlite3_file_control",
 			uint64(c.handle), uint64(schemaPtr),
 			uint64(op), uint64(ptr))
-		return nil, c.error(r)
 
 	case FCNTL_RESERVE_BYTES:
 		bytes := -1
 		if len(arg) > 0 {
 			bytes = arg[0].(int)
 		}
-		ptr := c.arena.new(4)
 		util.WriteUint32(c.mod, ptr, uint32(bytes))
-		r := c.call("sqlite3_file_control",
+		rc = c.call("sqlite3_file_control",
 			uint64(c.handle), uint64(schemaPtr),
 			uint64(op), uint64(ptr))
-		return int(util.ReadUint32(c.mod, ptr)), c.error(r)
+		res = int(util.ReadUint32(c.mod, ptr))
 
 	case FCNTL_DATA_VERSION:
-		ptr := c.arena.new(4)
-		r := c.call("sqlite3_file_control",
+		rc = c.call("sqlite3_file_control",
 			uint64(c.handle), uint64(schemaPtr),
 			uint64(op), uint64(ptr))
-		return util.ReadUint32(c.mod, ptr), c.error(r)
+		res = util.ReadUint32(c.mod, ptr)
 
 	case FCNTL_LOCKSTATE:
-		ptr := c.arena.new(4)
-		r := c.call("sqlite3_file_control",
+		rc = c.call("sqlite3_file_control",
 			uint64(c.handle), uint64(schemaPtr),
 			uint64(op), uint64(ptr))
-		return vfs.LockLevel(util.ReadUint32(c.mod, ptr)), c.error(r)
+		res = vfs.LockLevel(util.ReadUint32(c.mod, ptr))
 
 	case FCNTL_VFS_POINTER:
-		ptr := c.arena.new(4)
-		r := c.call("sqlite3_file_control",
+		rc = c.call("sqlite3_file_control",
 			uint64(c.handle), uint64(schemaPtr),
 			uint64(op), uint64(ptr))
-		const zNameOffset = 16
-		ptr = util.ReadUint32(c.mod, ptr)
-		ptr = util.ReadUint32(c.mod, ptr+zNameOffset)
-		name := util.ReadString(c.mod, ptr, _MAX_NAME)
-		return vfs.Find(name), c.error(r)
+		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:
-		ptr := c.arena.new(4)
-		r := c.call("sqlite3_file_control",
+		rc = c.call("sqlite3_file_control",
 			uint64(c.handle), uint64(schemaPtr),
 			uint64(op), uint64(ptr))
-		const fileHandleOffset = 4
-		ptr = util.ReadUint32(c.mod, ptr)
-		ptr = util.ReadUint32(c.mod, ptr+fileHandleOffset)
-		return util.GetHandle(c.ctx, ptr), c.error(r)
+		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)
+		}
 	}
 
-	return nil, MISUSE
+	if err := c.error(rc); err != nil {
+		return nil, err
+	}
+	return res, nil
 }
 
 // Limit allows the size of various constructs to be
@@ -234,10 +261,10 @@ func traceCallback(ctx context.Context, mod api.Module, evt TraceEvent, pDB, pAr
 	return rc
 }
 
-// WalCheckpoint checkpoints a WAL database.
+// WALCheckpoint checkpoints a WAL database.
 //
 // https://sqlite.org/c3ref/wal_checkpoint_v2.html
-func (c *Conn) WalCheckpoint(schema string, mode CheckpointMode) (nLog, nCkpt int, err error) {
+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)
@@ -250,19 +277,19 @@ func (c *Conn) WalCheckpoint(schema string, mode CheckpointMode) (nLog, nCkpt in
 	return nLog, nCkpt, c.error(r)
 }
 
-// WalAutoCheckpoint configures WAL auto-checkpoints.
+// WALAutoCheckpoint configures WAL auto-checkpoints.
 //
 // https://sqlite.org/c3ref/wal_autocheckpoint.html
-func (c *Conn) WalAutoCheckpoint(pages int) error {
+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
+// 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) {
+func (c *Conn) WALHook(cb func(db *Conn, schema string, pages int) error) {
 	var enable uint64
 	if cb != nil {
 		enable = 1
@@ -311,3 +338,46 @@ func (c *Conn) SoftHeapLimit(n int64) int64 {
 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

@@ -4,13 +4,16 @@ import (
 	"context"
 	"fmt"
 	"math"
+	"math/rand"
 	"net/url"
+	"runtime"
 	"strings"
 	"time"
 
+	"github.com/tetratelabs/wazero/api"
+
 	"github.com/ncruces/go-sqlite3/internal/util"
 	"github.com/ncruces/go-sqlite3/vfs"
-	"github.com/tetratelabs/wazero/api"
 )
 
 // Conn is a database connection handle.
@@ -23,7 +26,6 @@ type Conn struct {
 	interrupt  context.Context
 	pending    *Stmt
 	stmts      []*Stmt
-	timer      *time.Timer
 	busy       func(context.Context, int) bool
 	log        func(xErrorCode, string)
 	collation  func(*Conn, string)
@@ -35,7 +37,9 @@ type Conn struct {
 	rollback   func()
 	arena      arena
 
-	handle uint32
+	busy1st time.Time
+	busylst time.Time
+	handle  uint32
 }
 
 // Open calls [OpenFlags] with [OPEN_READWRITE], [OPEN_CREATE] and [OPEN_URI].
@@ -64,7 +68,7 @@ func OpenFlags(filename string, flags OpenFlag) (*Conn, error) {
 	return newConn(context.Background(), filename, flags)
 }
 
-type connKey struct{}
+type connKey = util.ConnKey
 
 func newConn(ctx context.Context, filename string, flags OpenFlag) (res *Conn, _ error) {
 	err := ctx.Err()
@@ -204,6 +208,7 @@ func (c *Conn) PrepareFlags(sql string, flags PrepareFlag) (stmt *Stmt, tail str
 	tailPtr := c.arena.new(ptrlen)
 	sqlPtr := c.arena.string(sql)
 
+	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))
@@ -371,8 +376,13 @@ func (c *Conn) checkInterrupt(handle uint32) {
 }
 
 func progressCallback(ctx context.Context, mod api.Module, _ uint32) (interrupt uint32) {
-	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.interrupt.Err() != nil {
-		interrupt = 1
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok {
+		if c.interrupt.Done() != nil {
+			runtime.Gosched()
+		}
+		if c.interrupt.Err() != nil {
+			interrupt = 1
+		}
 	}
 	return interrupt
 }
@@ -387,38 +397,20 @@ func (c *Conn) BusyTimeout(timeout time.Duration) error {
 }
 
 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 {
-		const delays = "\x01\x02\x05\x0a\x0f\x14\x19\x19\x19\x32\x32\x64"
-		const totals = "\x00\x01\x03\x08\x12\x21\x35\x4e\x67\x80\xb2\xe4"
-		const ndelay = int32(len(delays) - 1)
-
-		var delay, prior int32
-		if count <= ndelay {
-			delay = int32(delays[count])
-			prior = int32(totals[count])
-		} else {
-			delay = int32(delays[ndelay])
-			prior = int32(totals[ndelay]) + delay*(count-ndelay)
+		switch {
+		case count == 0:
+			c.busy1st = time.Now()
+		case time.Since(c.busy1st) >= time.Duration(tmout)*time.Millisecond:
+			return 0
 		}
-
-		if delay = min(delay, tmout-prior); delay > 0 {
-			delay := time.Duration(delay) * time.Millisecond
-			if c.interrupt.Done() == nil {
-				time.Sleep(delay)
-				return 1
-			}
-			if c.timer == nil {
-				c.timer = time.NewTimer(delay)
-			} else {
-				c.timer.Reset(delay)
-			}
-			select {
-			case <-c.interrupt.Done():
-				c.timer.Stop()
-			case <-c.timer.C:
-				return 1
-			}
+		if time.Since(c.busylst) < time.Millisecond {
+			const sleepIncrement = 2*1024*1024 - 1 // power of two, ~2ms
+			time.Sleep(time.Duration(rand.Int63() & sleepIncrement))
 		}
+		c.busylst = time.Now()
+		return 1
 	}
 	return 0
 }
@@ -457,8 +449,8 @@ func busyCallback(ctx context.Context, mod api.Module, pDB uint32, count int32)
 // https://sqlite.org/c3ref/db_status.html
 func (c *Conn) Status(op DBStatus, reset bool) (current, highwater int, err error) {
 	defer c.arena.mark()()
-	hiPtr := c.arena.new(4)
-	curPtr := c.arena.new(4)
+	hiPtr := c.arena.new(intlen)
+	curPtr := c.arena.new(intlen)
 
 	var i uint64
 	if reset {
@@ -484,8 +476,8 @@ func (c *Conn) TableColumnMetadata(schema, table, column string) (declType, coll
 	declTypePtr := c.arena.new(ptrlen)
 	collSeqPtr := c.arena.new(ptrlen)
 	notNullPtr := c.arena.new(ptrlen)
-	primaryKeyPtr := c.arena.new(ptrlen)
 	autoIncPtr := c.arena.new(ptrlen)
+	primaryKeyPtr := c.arena.new(ptrlen)
 	if schema != "" {
 		schemaPtr = c.arena.string(schema)
 	}
@@ -499,8 +491,12 @@ func (c *Conn) TableColumnMetadata(schema, table, column string) (declType, coll
 		uint64(declTypePtr), uint64(collSeqPtr),
 		uint64(notNullPtr), uint64(primaryKeyPtr), uint64(autoIncPtr))
 	if err = c.error(r); err == nil && column != "" {
-		declType = util.ReadString(c.mod, util.ReadUint32(c.mod, declTypePtr), _MAX_NAME)
-		collSeq = util.ReadString(c.mod, util.ReadUint32(c.mod, collSeqPtr), _MAX_NAME)
+		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
@@ -519,10 +515,3 @@ func (c *Conn) stmtsIter(yield func(*Stmt) bool) {
 		}
 	}
 }
-
-// DriverConn is implemented by the SQLite [database/sql] driver connection.
-//
-// Deprecated: use [github.com/ncruces/go-sqlite3/driver.Conn] instead.
-type DriverConn interface {
-	Raw() *Conn
-}

const.go

@@ -13,6 +13,7 @@ const (
 	_MAX_FUNCTION_ARG = 100
 
 	ptrlen = 4
+	intlen = 4
 )
 
 // ErrorCode is a result code that [Error.Code] might return.
@@ -165,6 +166,7 @@ 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
@@ -177,6 +179,7 @@ const (
 	DETERMINISTIC FunctionFlag = 0x000000800
 	DIRECTONLY    FunctionFlag = 0x000080000
 	INNOCUOUS     FunctionFlag = 0x000200000
+	SELFORDER1    FunctionFlag = 0x002000000
 	// SUBTYPE        FunctionFlag = 0x000100000
 	// RESULT_SUBTYPE FunctionFlag = 0x001000000
 )
@@ -217,6 +220,7 @@ const (
 	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.
@@ -245,6 +249,7 @@ const (
 	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].

context.go

@@ -89,6 +89,7 @@ func (ctx Context) ResultText(value string) {
 }
 
 // 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) {

driver/driver.go

@@ -81,6 +81,7 @@ import (
 	"fmt"
 	"io"
 	"net/url"
+	"reflect"
 	"strings"
 	"time"
 	"unsafe"
@@ -107,17 +108,17 @@ func init() {
 // The second callback is called before the driver closes a connection.
 // The [sqlite3.Conn] can be used to execute queries, register functions, etc.
 func Open(dataSourceName string, fn ...func(*sqlite3.Conn) error) (*sql.DB, error) {
-	var drv SQLite
 	if len(fn) > 2 {
 		return nil, sqlite3.MISUSE
 	}
+	var init, term func(*sqlite3.Conn) error
 	if len(fn) > 1 {
-		drv.term = fn[1]
+		term = fn[1]
 	}
 	if len(fn) > 0 {
-		drv.init = fn[0]
+		init = fn[0]
 	}
-	c, err := drv.OpenConnector(dataSourceName)
+	c, err := newConnector(dataSourceName, init, term)
 	if err != nil {
 		return nil, err
 	}
@@ -125,10 +126,7 @@ func Open(dataSourceName string, fn ...func(*sqlite3.Conn) error) (*sql.DB, erro
 }
 
 // SQLite implements [database/sql/driver.Driver].
-type SQLite struct {
-	init func(*sqlite3.Conn) error
-	term func(*sqlite3.Conn) error
-}
+type SQLite struct{}
 
 var (
 	// Ensure these interfaces are implemented:
@@ -137,7 +135,7 @@ var (
 
 // Open implements [database/sql/driver.Driver].
 func (d *SQLite) Open(name string) (driver.Conn, error) {
-	c, err := d.newConnector(name)
+	c, err := newConnector(name, nil, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -146,11 +144,11 @@ func (d *SQLite) Open(name string) (driver.Conn, error) {
 
 // OpenConnector implements [database/sql/driver.DriverContext].
 func (d *SQLite) OpenConnector(name string) (driver.Connector, error) {
-	return d.newConnector(name)
+	return newConnector(name, nil, nil)
 }
 
-func (d *SQLite) newConnector(name string) (*connector, error) {
-	c := connector{driver: d, name: name}
+func newConnector(name string, init, term func(*sqlite3.Conn) error) (*connector, error) {
+	c := connector{name: name, init: init, term: term}
 
 	var txlock, timefmt string
 	if strings.HasPrefix(name, "file:") {
@@ -190,7 +188,8 @@ func (d *SQLite) newConnector(name string) (*connector, error) {
 }
 
 type connector struct {
-	driver  *SQLite
+	init    func(*sqlite3.Conn) error
+	term    func(*sqlite3.Conn) error
 	name    string
 	txLock  string
 	tmRead  sqlite3.TimeFormat
@@ -199,7 +198,7 @@ type connector struct {
 }
 
 func (n *connector) Driver() driver.Driver {
-	return n.driver
+	return &SQLite{}
 }
 
 func (n *connector) Connect(ctx context.Context) (res driver.Conn, err error) {
@@ -228,13 +227,13 @@ func (n *connector) Connect(ctx context.Context) (res driver.Conn, err error) {
 			return nil, err
 		}
 	}
-	if n.driver.init != nil {
-		err = n.driver.init(c.Conn)
+	if n.init != nil {
+		err = n.init(c.Conn)
 		if err != nil {
 			return nil, err
 		}
 	}
-	if n.pragmas || n.driver.init != nil {
+	if n.pragmas || n.init != nil {
 		s, _, err := c.Conn.Prepare(`PRAGMA query_only`)
 		if err != nil {
 			return nil, err
@@ -250,9 +249,9 @@ func (n *connector) Connect(ctx context.Context) (res driver.Conn, err error) {
 			return nil, err
 		}
 	}
-	if n.driver.term != nil {
+	if n.term != nil {
 		err = c.Conn.Trace(sqlite3.TRACE_CLOSE, func(sqlite3.TraceEvent, any, any) error {
-			return n.driver.term(c.Conn)
+			return n.term(c.Conn)
 		})
 		if err != nil {
 			return nil, err
@@ -275,6 +274,7 @@ func (n *connector) Connect(ctx context.Context) (res driver.Conn, err error) {
 //	if err != nil {
 //		log.Fatal(err)
 //	}
+//	defer conn.Close()
 //
 //	err = conn.Raw(func(driverConn any) error {
 //		conn := driverConn.(driver.Conn)
@@ -288,6 +288,8 @@ func (n *connector) Connect(ctx context.Context) (res driver.Conn, err error) {
 type Conn interface {
 	Raw() *sqlite3.Conn
 	driver.Conn
+	driver.ConnBeginTx
+	driver.ConnPrepareContext
 }
 
 type conn struct {
@@ -301,10 +303,8 @@ type conn struct {
 
 var (
 	// Ensure these interfaces are implemented:
-	_ Conn                      = &conn{}
-	_ driver.ConnBeginTx        = &conn{}
-	_ driver.ConnPrepareContext = &conn{}
-	_ driver.ExecerContext      = &conn{}
+	_ Conn                 = &conn{}
+	_ driver.ExecerContext = &conn{}
 )
 
 func (c *conn) Raw() *sqlite3.Conn {
@@ -380,7 +380,7 @@ func (c *conn) PrepareContext(ctx context.Context, query string) (driver.Stmt, e
 	if err != nil {
 		return nil, err
 	}
-	if tail != "" {
+	if notWhitespace(tail) {
 		s.Close()
 		return nil, util.TailErr
 	}
@@ -581,8 +581,22 @@ type rows struct {
 	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{}
@@ -606,21 +620,42 @@ func (r *rows) Columns() []string {
 	return r.names
 }
 
-func (r *rows) loadTypes() {
+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
 	}
 }
 
@@ -637,7 +672,7 @@ func (r *rows) declType(index int) string {
 }
 
 func (r *rows) ColumnTypeDatabaseTypeName(index int) string {
-	r.loadTypes()
+	r.loadColumnMetadata()
 	decltype := r.types[index]
 	if len := len(decltype); len > 0 && decltype[len-1] == ')' {
 		if i := strings.LastIndexByte(decltype, '('); i >= 0 {
@@ -648,13 +683,57 @@ func (r *rows) ColumnTypeDatabaseTypeName(index int) string {
 }
 
 func (r *rows) ColumnTypeNullable(index int) (nullable, ok bool) {
-	r.loadTypes()
+	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()
+	}
+}
+
 func (r *rows) Next(dest []driver.Value) error {
 	old := r.Stmt.Conn().SetInterrupt(r.ctx)
 	defer r.Stmt.Conn().SetInterrupt(old)
@@ -667,7 +746,7 @@ func (r *rows) Next(dest []driver.Value) error {
 	}
 
 	data := unsafe.Slice((*any)(unsafe.SliceData(dest)), len(dest))
-	err := r.Stmt.Columns(data)
+	err := r.Stmt.Columns(data...)
 	for i := range dest {
 		if t, ok := r.decodeTime(i, dest[i]); ok {
 			dest[i] = t

driver/driver_test.go

@@ -7,6 +7,7 @@ import (
 	"errors"
 	"math"
 	"net/url"
+	"reflect"
 	"testing"
 	"time"
 
@@ -224,8 +225,8 @@ func Test_Prepare(t *testing.T) {
 	}
 
 	_, err = db.Prepare(`SELECT 1; `)
-	if err.Error() != string(util.TailErr) {
-		t.Error("want tailErr")
+	if err != nil {
+		t.Error(err)
 	}
 
 	_, err = db.Prepare(`SELECT 1; SELECT`)
@@ -365,3 +366,104 @@ func Test_time(t *testing.T) {
 		})
 	}
 }
+
+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

@@ -1,4 +1,4 @@
-//go:build (linux || darwin || windows || freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock) && !sqlite3_nosys
+//go:build linux || darwin || windows || freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock || sqlite3_dotlk
 
 package driver_test
 

driver/example_test.go

@@ -1,4 +1,4 @@
-//go:build (linux || darwin || windows || freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock) && !sqlite3_nosys
+//go:build linux || darwin || windows || freebsd || openbsd || netbsd || dragonfly || illumos || sqlite3_flock || sqlite3_dotlk
 
 package driver_test
 

driver/savepoint_test.go

@@ -6,6 +6,7 @@ import (
 
 	"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"
 )
 

driver/time.go

@@ -1,8 +1,6 @@
 package driver
 
-import (
-	"time"
-)
+import "time"
 
 // Convert a string in [time.RFC3339Nano] format into a [time.Time]
 // if it roundtrips back to the same string.

driver/time_test.go

@@ -27,12 +27,12 @@ func Fuzz_stringOrTime_1(f *testing.F) {
 			// Make sure times round-trip to the same string:
 			// https://pkg.go.dev/database/sql#Rows.Scan
 			if v.Format(time.RFC3339Nano) != str {
-				t.Fatalf("did not round-trip: %q", str)
+				t.Errorf("did not round-trip: %q", str)
 			}
 		} else {
 			date, err := time.Parse(time.RFC3339Nano, str)
 			if err == nil && date.Format(time.RFC3339Nano) == str {
-				t.Fatalf("would round-trip: %q", str)
+				t.Errorf("would round-trip: %q", str)
 			}
 		}
 	})

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
+		})
+	})
+}

embed/README.md

@@ -1,6 +1,6 @@
 # Embeddable Wasm build of SQLite
 
-This folder includes an embeddable Wasm build of SQLite 3.46.1 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:
@@ -36,6 +36,6 @@ You can use your own custom build of SQLite.
 Examples of custom builds of SQLite are:
 - [`github.com/ncruces/go-sqlite3/embed/bcw2`](https://github.com/ncruces/go-sqlite3/tree/main/embed/bcw2)
   built from a branch supporting [`BEGIN CONCURRENT`](https://sqlite.org/src/doc/begin-concurrent/doc/begin_concurrent.md)
-  and [Wal2](https://www.sqlite.org/cgi/src/doc/wal2/doc/wal2.md).
+  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/README.md

@@ -1,13 +1,19 @@
 # Embeddable Wasm build of SQLite
 
-This folder includes an embeddable Wasm build of SQLite 3.46.1, including the experimental
+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://www.sqlite.org/cgi/src/doc/wal2/doc/wal2.md) patches.
+[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 both features.
+> 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.

embed/bcw2/bcw2_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/ncruces/go-sqlite3/driver"
+	"github.com/ncruces/go-sqlite3/ext/stats"
 	"github.com/ncruces/go-sqlite3/vfs"
 )
 
@@ -15,7 +16,7 @@ func Test_bcw2(t *testing.T) {
 
 	tmp := filepath.ToSlash(filepath.Join(t.TempDir(), "test.db"))
 
-	db, err := driver.Open("file:" + tmp + "?_pragma=journal_mode(wal2)&_txlock=concurrent")
+	db, err := driver.Open("file:"+tmp+"?_pragma=journal_mode(wal2)&_txlock=concurrent", stats.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -32,6 +33,16 @@ func Test_bcw2(t *testing.T) {
 		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)
@@ -42,7 +53,7 @@ func Test_bcw2(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if version != "3.46.1" {
+	if version != "3.48.0" {
 		t.Error(version)
 	}
 }

embed/bcw2/build.sh

@@ -13,14 +13,15 @@ mkdir -p build/ext/
 cp "$ROOT"/sqlite3/*.[ch] build/
 cp "$ROOT"/sqlite3/*.patch build/
 
-curl -# https://www.sqlite.org/src/tarball/sqlite.tar.gz?r=bedrock-3.46 | tar xz
+# 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
+	MSYS_NO_PATHCONV=1 nmake /f makefile.msc sqlite3.c "OPTS=-DSQLITE_ENABLE_UPDATE_DELETE_LIMIT -DSQLITE_ENABLE_ORDERED_SET_AGGREGATES"
 else
-	sh configure
-	make sqlite3.c
+	sh configure --enable-update-limit
+	OPTS=-DSQLITE_ENABLE_ORDERED_SET_AGGREGATES make sqlite3.c
 fi
 cd ~-
 
@@ -37,7 +38,7 @@ mv sqlite/ext/misc/spellfix.c   build/ext/
 mv sqlite/ext/misc/uint.c       build/ext/
 
 cd build
-cat *.patch | patch --no-backup-if-mismatch
+cat *.patch | patch -p0 --no-backup-if-mismatch
 cd ~-
 
 "$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -g0 -O2 \
@@ -45,7 +46,7 @@ cd ~-
 	-o bcw2.wasm "build/main.c" \
 	-I"build" \
 	-mexec-model=reactor \
-	-matomics -msimd128 -mmutable-globals -mmultivalue \
+	-msimd128 -mmutable-globals -mmultivalue \
 	-mbulk-memory -mreference-types \
 	-mnontrapping-fptoint -msign-ext \
 	-fno-stack-protector -fno-stack-clash-protection \
@@ -53,6 +54,7 @@ cd ~-
 	-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)
 

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.21.3
+
+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.21.3 h1:hHkfNQLcbnxPJZhC/RGw9SwP3bfkv/Y0xUHWsr1CdMQ=
+github.com/ncruces/go-sqlite3 v0.21.3/go.mod h1:zxMOaSG5kFYVFK4xQa0pdwIszqxqJ0W0BxBgwdrNjuA=
+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

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

embed/build.sh

@@ -14,7 +14,7 @@ trap 'rm -f sqlite3.tmp' EXIT
 	-o sqlite3.wasm "$ROOT/sqlite3/main.c" \
 	-I"$ROOT/sqlite3" \
 	-mexec-model=reactor \
-	-matomics -msimd128 -mmutable-globals -mmultivalue \
+	-msimd128 -mmutable-globals -mmultivalue \
 	-mbulk-memory -mreference-types \
 	-mnontrapping-fptoint -msign-ext \
 	-fno-stack-protector -fno-stack-clash-protection \

embed/exports.txt

@@ -77,6 +77,7 @@ sqlite3_get_autocommit
 sqlite3_get_auxdata
 sqlite3_hard_heap_limit64
 sqlite3_interrupt
+sqlite3_invoke_busy_handler_go
 sqlite3_last_insert_rowid
 sqlite3_limit
 sqlite3_malloc64

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

@@ -19,7 +19,7 @@ func Test_init(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if version != "3.46.1" {
+	if version != "3.48.0" {
 		t.Error(version)
 	}
 }

error.go

@@ -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))
@@ -136,6 +141,11 @@ 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:

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/blobio/blob.go

@@ -44,6 +44,8 @@ func Register(db *sqlite3.Conn) error {
 type OpenCallback func(*sqlite3.Blob, ...sqlite3.Value) error
 
 func readblob(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	_ = arg[5] // bounds check
+
 	blob, err := getAuxBlob(ctx, arg, false)
 	if err != nil {
 		ctx.ResultError(err)
@@ -78,6 +80,8 @@ func readblob(ctx sqlite3.Context, arg ...sqlite3.Value) {
 }
 
 func writeblob(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	_ = arg[5] // bounds check
+
 	blob, err := getAuxBlob(ctx, arg, true)
 	if err != nil {
 		ctx.ResultError(err)

ext/bloom/bloom.go

@@ -13,6 +13,7 @@ import (
 	"strconv"
 
 	"github.com/dchest/siphash"
+
 	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/internal/util"
 )

ext/closure/closure.go

@@ -12,7 +12,7 @@ import (
 
 	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/internal/util"
-	"github.com/ncruces/go-sqlite3/util/vtabutil"
+	"github.com/ncruces/go-sqlite3/util/sql3util"
 )
 
 const (
@@ -39,17 +39,17 @@ func Register(db *sqlite3.Conn) error {
 			)
 
 			for _, arg := range arg {
-				key, val := vtabutil.NamedArg(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 = vtabutil.Unquote(val)
+					table = sql3util.Unquote(val)
 				case "idcolumn":
-					column = vtabutil.Unquote(val)
+					column = sql3util.Unquote(val)
 				case "parentcolumn":
-					parent = vtabutil.Unquote(val)
+					parent = sql3util.Unquote(val)
 				default:
 					return nil, fmt.Errorf("transitive_closure: unknown %q parameter", key)
 				}
@@ -84,10 +84,11 @@ func (c *closure) BestIndex(idx *sqlite3.IndexInfo) error {
 	cost := 1e7
 
 	for i, cst := range idx.Constraint {
-		if !cst.Usable {
+		switch {
+		case !cst.Usable:
 			continue
-		}
-		if plan&1 == 0 && cst.Column == _COL_ROOT {
+
+		case plan&1 == 0 && cst.Column == _COL_ROOT:
 			switch cst.Op {
 			case sqlite3.INDEX_CONSTRAINT_EQ:
 				plan |= 1
@@ -97,9 +98,8 @@ func (c *closure) BestIndex(idx *sqlite3.IndexInfo) error {
 					Omit:      true,
 				}
 			}
-			continue
-		}
-		if plan&0xf0 == 0 && cst.Column == _COL_DEPTH {
+
+		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
@@ -110,9 +110,8 @@ func (c *closure) BestIndex(idx *sqlite3.IndexInfo) error {
 					plan |= 2
 				}
 			}
-			continue
-		}
-		if plan&0xf00 == 0 && cst.Column == _COL_TABLENAME {
+
+		case plan&0xf00 == 0 && cst.Column == _COL_TABLENAME:
 			switch cst.Op {
 			case sqlite3.INDEX_CONSTRAINT_EQ:
 				plan |= posi << 8
@@ -123,9 +122,8 @@ func (c *closure) BestIndex(idx *sqlite3.IndexInfo) error {
 					Omit:      true,
 				}
 			}
-			continue
-		}
-		if plan&0xf000 == 0 && cst.Column == _COL_IDCOLUMN {
+
+		case plan&0xf000 == 0 && cst.Column == _COL_IDCOLUMN:
 			switch cst.Op {
 			case sqlite3.INDEX_CONSTRAINT_EQ:
 				plan |= posi << 12
@@ -135,9 +133,8 @@ func (c *closure) BestIndex(idx *sqlite3.IndexInfo) error {
 					Omit:      true,
 				}
 			}
-			continue
-		}
-		if plan&0xf0000 == 0 && cst.Column == _COL_PARENTCOLUMN {
+
+		case plan&0xf0000 == 0 && cst.Column == _COL_PARENTCOLUMN:
 			switch cst.Op {
 			case sqlite3.INDEX_CONSTRAINT_EQ:
 				plan |= posi << 16
@@ -147,7 +144,6 @@ func (c *closure) BestIndex(idx *sqlite3.IndexInfo) error {
 					Omit:      true,
 				}
 			}
-			continue
 		}
 	}
 

ext/csv/arg.go

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

ext/csv/arg_test.go

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

ext/csv/csv.go

@@ -18,7 +18,7 @@ import (
 	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/internal/util"
 	"github.com/ncruces/go-sqlite3/util/osutil"
-	"github.com/ncruces/go-sqlite3/util/vtabutil"
+	"github.com/ncruces/go-sqlite3/util/sql3util"
 )
 
 // Register registers the CSV virtual table.
@@ -44,17 +44,17 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
 		)
 
 		for _, arg := range arg {
-			key, val := vtabutil.NamedArg(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 = vtabutil.Unquote(val)
+				filename = sql3util.Unquote(val)
 			case "data":
-				data = vtabutil.Unquote(val)
+				data = sql3util.Unquote(val)
 			case "schema":
-				schema = vtabutil.Unquote(val)
+				schema = sql3util.Unquote(val)
 			case "header":
 				header, err = boolArg(key, val)
 			case "columns":

ext/csv/types.go

@@ -3,7 +3,7 @@ package csv
 import (
 	"strings"
 
-	"github.com/ncruces/go-sqlite3/util/vtabutil"
+	"github.com/ncruces/go-sqlite3/util/sql3util"
 )
 
 type affinity byte
@@ -17,7 +17,7 @@ const (
 )
 
 func getColumnAffinities(schema string) ([]affinity, error) {
-	tab, err := vtabutil.Parse(schema)
+	tab, err := sql3util.ParseTable(schema)
 	if err != nil {
 		return nil, err
 	}

ext/hash/hash_test.go

@@ -7,15 +7,16 @@ import (
 	_ "crypto/sha512"
 	"testing"
 
-	"github.com/ncruces/go-sqlite3/driver"
-	_ "github.com/ncruces/go-sqlite3/embed"
-	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
-	"github.com/ncruces/go-sqlite3/vfs/memdb"
 	_ "golang.org/x/crypto/blake2b"
 	_ "golang.org/x/crypto/blake2s"
 	_ "golang.org/x/crypto/md4"
 	_ "golang.org/x/crypto/ripemd160"
 	_ "golang.org/x/crypto/sha3"
+
+	"github.com/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) {

ext/lines/lines.go

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

ext/lines/lines_test.go

@@ -163,7 +163,7 @@ func Test_lines_test(t *testing.T) {
 	}
 	defer db.Close()
 
-	rows, err := db.Query(`SELECT rowid, line FROM lines_read(?)`, "lines_test.go")
+	rows, err := db.Query(`SELECT rowid, line FROM lines_read(?, '}')`, "lines_test.go")
 	if errors.Is(err, os.ErrNotExist) {
 		t.Skip(err)
 	}

ext/regexp/regexp.go

@@ -1,9 +1,11 @@
 // Package regexp provides additional regular expression functions.
 //
 // It provides the following Unicode aware functions:
-//   - regexp_like(),
-//   - regexp_substr(),
-//   - regexp_replace(),
+//   - regexp_like(text, pattern),
+//   - regexp_count(text, pattern [, start]),
+//   - regexp_instr(text, pattern [, start [, N [, endoption [, subexpr ]]]]),
+//   - regexp_substr(text, pattern [, start [, N [, subexpr ]]]),
+//   - regexp_replace(text, pattern, replacement [, start [, N ]]),
 //   - and a REGEXP operator.
 //
 // The implementation uses Go [regexp/syntax] for regular expressions.
@@ -14,6 +16,7 @@ package regexp
 import (
 	"errors"
 	"regexp"
+	"strings"
 
 	"github.com/ncruces/go-sqlite3"
 )
@@ -24,8 +27,39 @@ func Register(db *sqlite3.Conn) error {
 	return errors.Join(
 		db.CreateFunction("regexp", 2, flags, regex),
 		db.CreateFunction("regexp_like", 2, flags, regexLike),
+		db.CreateFunction("regexp_count", 2, flags, regexCount),
+		db.CreateFunction("regexp_count", 3, flags, regexCount),
+		db.CreateFunction("regexp_instr", 2, flags, regexInstr),
+		db.CreateFunction("regexp_instr", 3, flags, regexInstr),
+		db.CreateFunction("regexp_instr", 4, flags, regexInstr),
+		db.CreateFunction("regexp_instr", 5, flags, regexInstr),
+		db.CreateFunction("regexp_instr", 6, flags, regexInstr),
 		db.CreateFunction("regexp_substr", 2, flags, regexSubstr),
-		db.CreateFunction("regexp_replace", 3, flags, regexReplace))
+		db.CreateFunction("regexp_substr", 3, flags, regexSubstr),
+		db.CreateFunction("regexp_substr", 4, flags, regexSubstr),
+		db.CreateFunction("regexp_substr", 5, flags, regexSubstr),
+		db.CreateFunction("regexp_replace", 3, flags, regexReplace),
+		db.CreateFunction("regexp_replace", 4, flags, regexReplace),
+		db.CreateFunction("regexp_replace", 5, flags, regexReplace))
+}
+
+// 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) {
@@ -42,37 +76,168 @@ func load(ctx sqlite3.Context, i int, expr string) (*regexp.Regexp, error) {
 }
 
 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) // notest
-	} else {
-		ctx.ResultBool(re.Match(arg[1].RawText()))
+		ctx.ResultError(err)
+		return // notest
 	}
+	text := arg[1].RawText()
+	ctx.ResultBool(re.Match(text))
 }
 
 func regexLike(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	re, err := load(ctx, 1, arg[1].Text())
 	if err != nil {
-		ctx.ResultError(err) // notest
-	} else {
-		ctx.ResultBool(re.Match(arg[0].RawText()))
+		ctx.ResultError(err)
+		return // notest
 	}
+
+	text := arg[0].RawText()
+	ctx.ResultBool(re.Match(text))
+}
+
+func regexCount(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	re, err := load(ctx, 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) // notest
-	} else {
-		ctx.ResultRawText(re.Find(arg[0].RawText()))
+		ctx.ResultError(err)
+		return // notest
+	}
+
+	text := arg[0].RawText()
+	var pos, n, subexpr int
+	if len(arg) > 2 {
+		pos = arg[2].Int()
+	}
+	if len(arg) > 3 {
+		n = arg[3].Int()
+	}
+	if len(arg) > 4 {
+		subexpr = arg[4].Int()
+	}
+
+	loc := regexFind(re, text, pos, n, subexpr)
+	if loc != nil {
+		ctx.ResultRawText(text[loc[0]:loc[1]])
+	}
+}
+
+func regexInstr(ctx sqlite3.Context, arg ...sqlite3.Value) {
+	re, err := load(ctx, 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) // notest
-	} else {
-		ctx.ResultRawText(re.ReplaceAll(arg[0].RawText(), arg[2].RawText()))
+		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

@@ -1,6 +1,8 @@
 package regexp
 
 import (
+	"database/sql"
+	"regexp"
 	"testing"
 
 	"github.com/ncruces/go-sqlite3/driver"
@@ -29,18 +31,47 @@ func TestRegister(t *testing.T) {
 		{`regexp_like('Hello', 'elo')`, "0"},
 		{`regexp_like('Hello', 'ell')`, "1"},
 		{`regexp_like('Hello', 'el.')`, "1"},
+		{`regexp_count('Hello', 'l')`, "2"},
+		{`regexp_instr('Hello', 'el.')`, "2"},
+		{`regexp_instr('Hello', '.', 6)`, ""},
 		{`regexp_substr('Hello', 'el.')`, "ell"},
 		{`regexp_replace('Hello', 'llo', 'll')`, "Hell"},
+		// https://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 string
+		var got sql.NullString
 		err := db.QueryRow(`SELECT ` + tt.test).Scan(&got)
 		if err != nil {
 			t.Fatal(err)
 		}
-		if got != tt.want {
-			t.Errorf("got %q, want %q", got, tt.want)
+		if got.String != tt.want {
+			t.Errorf("got %q, want %q", got.String, tt.want)
 		}
 	}
 }
@@ -58,6 +89,8 @@ func TestRegister_errors(t *testing.T) {
 	tests := []string{
 		`'' REGEXP ?`,
 		`regexp_like('', ?)`,
+		`regexp_count('', ?)`,
+		`regexp_instr('', ?)`,
 		`regexp_substr('', ?)`,
 		`regexp_replace('', ?, '')`,
 	}
@@ -69,3 +102,25 @@ func TestRegister_errors(t *testing.T) {
 		}
 	}
 }
+
+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/stats/boolean.go

@@ -26,21 +26,21 @@ func (b *boolean) Value(ctx sqlite3.Context) {
 }
 
 func (b *boolean) Step(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	if arg[0].Type() == sqlite3.NULL {
-		return
-	}
-	if arg[0].Bool() {
+	a := arg[0]
+	if a.Bool() {
 		b.count++
 	}
-	b.total++
+	if a.Type() != sqlite3.NULL {
+		b.total++
+	}
 }
 
 func (b *boolean) Inverse(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	if arg[0].Type() == sqlite3.NULL {
-		return
-	}
-	if arg[0].Bool() {
+	a := arg[0]
+	if a.Bool() {
 		b.count--
 	}
-	b.total--
+	if a.Type() != sqlite3.NULL {
+		b.total--
+	}
 }

ext/stats/percentile.go

@@ -13,6 +13,7 @@ import (
 
 const (
 	median = iota
+	percentile_100
 	percentile_cont
 	percentile_disc
 )
@@ -39,8 +40,14 @@ func (q *percentile) Step(ctx sqlite3.Context, arg ...sqlite3.Value) {
 }
 
 func (q *percentile) Inverse(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	// Implementing inverse allows certain queries that don't really need it to succeed.
-	ctx.ResultError(util.ErrorString("percentile: may not be used as a window function"))
+	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) {
@@ -54,13 +61,13 @@ func (q *percentile) Value(ctx sqlite3.Context) {
 		floats []float64
 	)
 	if q.kind == median {
-		float, err = getPercentile(q.nums, 0.5, false)
+		float, err = q.at(0.5)
 		ctx.ResultFloat(float)
 	} else if err = json.Unmarshal(q.arg1, &float); err == nil {
-		float, err = getPercentile(q.nums, float, q.kind == percentile_disc)
+		float, err = q.at(float)
 		ctx.ResultFloat(float)
 	} else if err = json.Unmarshal(q.arg1, &floats); err == nil {
-		err = getPercentiles(q.nums, floats, q.kind == percentile_disc)
+		err = q.atMore(floats)
 		ctx.ResultJSON(floats)
 	}
 	if err != nil {
@@ -68,25 +75,28 @@ func (q *percentile) Value(ctx sqlite3.Context) {
 	}
 }
 
-func getPercentile(nums []float64, pos float64, disc bool) (float64, error) {
+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(nums)-1))
-	m0 := quick.Select(nums, int(i))
+	i, f := math.Modf(pos * float64(len(q.nums)-1))
+	m0 := quick.Select(q.nums, int(i))
 
-	if f == 0 || disc {
+	if f == 0 || q.kind == percentile_disc {
 		return m0, nil
 	}
 
-	m1 := slices.Min(nums[int(i)+1:])
-	return math.FMA(f, m1, math.FMA(-f, m0, m0)), nil
+	m1 := slices.Min(q.nums[int(i)+1:])
+	return util.Lerp(m0, m1, f), nil
 }
 
-func getPercentiles(nums []float64, pos []float64, disc bool) error {
+func (q *percentile) atMore(pos []float64) error {
 	for i := range pos {
-		v, err := getPercentile(nums, pos[i], disc)
+		v, err := q.at(pos[i])
 		if err != nil {
 			return err
 		}

ext/stats/percentile_test.go

@@ -31,6 +31,7 @@ func TestRegister_percentile(t *testing.T) {
 	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`)
@@ -41,11 +42,14 @@ func TestRegister_percentile(t *testing.T) {
 		if got := stmt.ColumnFloat(0); got != 10 {
 			t.Errorf("got %v, want 10", got)
 		}
-		if got := stmt.ColumnFloat(1); got != 7 {
+		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(2, &got); err != nil {
+		if err := stmt.ColumnJSON(3, &got); err != nil {
 			t.Error(err)
 		}
 		if !slices.Equal(got, []float64{6.25, 10, 13.75}) {
@@ -54,9 +58,44 @@ func TestRegister_percentile(t *testing.T) {
 	}
 	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
@@ -71,8 +110,11 @@ func TestRegister_percentile(t *testing.T) {
 		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(2, &got); err != nil {
+		if err := stmt.ColumnJSON(3, &got); err != nil {
 			t.Error(err)
 		}
 		if !slices.Equal(got, []float64{4, 4, 4}) {
@@ -84,6 +126,7 @@ func TestRegister_percentile(t *testing.T) {
 	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
@@ -101,6 +144,9 @@ func TestRegister_percentile(t *testing.T) {
 		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()
 

ext/stats/stats.go

@@ -53,6 +53,7 @@ import (
 // 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)),
@@ -71,9 +72,10 @@ func Register(db *sqlite3.Conn) error {
 		db.CreateWindowFunction("regr_intercept", 2, flags, newCovariance(regr_intercept)),
 		db.CreateWindowFunction("regr_count", 2, flags, newCovariance(regr_count)),
 		db.CreateWindowFunction("regr_json", 2, flags, newCovariance(regr_json)),
-		db.CreateWindowFunction("median", 1, flags, newPercentile(median)),
-		db.CreateWindowFunction("percentile_cont", 2, flags, newPercentile(percentile_cont)),
-		db.CreateWindowFunction("percentile_disc", 2, flags, newPercentile(percentile_disc)),
+		db.CreateWindowFunction("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)))
 }

ext/unicode/unicode.go

@@ -28,14 +28,15 @@ import (
 	"unicode"
 	"unicode/utf8"
 
-	"github.com/ncruces/go-sqlite3"
-	"github.com/ncruces/go-sqlite3/internal/util"
 	"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.
@@ -188,6 +189,7 @@ func like(ctx sqlite3.Context, arg ...sqlite3.Value) {
 			return
 		}
 	}
+	_ = arg[1] // bounds check
 
 	type likeData struct {
 		*regexp.Regexp

ext/uuid/uuid.go

@@ -9,6 +9,7 @@ import (
 	"fmt"
 
 	"github.com/google/uuid"
+
 	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/internal/util"
 )

ext/uuid/uuid_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/google/uuid"
+
 	"github.com/ncruces/go-sqlite3/driver"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"

func.go

@@ -4,8 +4,9 @@ import (
 	"context"
 	"sync"
 
-	"github.com/ncruces/go-sqlite3/internal/util"
 	"github.com/tetratelabs/wazero/api"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
 )
 
 // CollationNeeded registers a callback to be invoked

go.mod

@@ -5,17 +5,20 @@ go 1.21
 toolchain go1.23.0
 
 require (
-	github.com/dchest/siphash v1.2.3
-	github.com/google/uuid v1.6.0
 	github.com/ncruces/julianday v1.0.0
 	github.com/ncruces/sort v0.1.2
-	github.com/psanford/httpreadat v0.1.0
-	github.com/tetratelabs/wazero v1.8.1
-	golang.org/x/crypto v0.28.0
-	golang.org/x/sync v0.8.0
-	golang.org/x/sys v0.26.0
-	golang.org/x/text v0.19.0
-	lukechampine.com/adiantum v1.1.1
+	github.com/tetratelabs/wazero v1.8.2
+	golang.org/x/crypto v0.32.0
+	golang.org/x/sys v0.29.0
+)
+
+require (
+	github.com/dchest/siphash v1.2.3 // ext/bloom
+	github.com/google/uuid v1.6.0 // ext/uuid
+	github.com/psanford/httpreadat v0.1.0 // example
+	golang.org/x/sync v0.10.0 // test
+	golang.org/x/text v0.21.0 // ext/unicode
+	lukechampine.com/adiantum v1.1.1 // vfs/adiantum
 )
 
 retract v0.4.0 // tagged from the wrong branch

go.sum

@@ -8,15 +8,15 @@ github.com/ncruces/sort v0.1.2 h1:zKQ9CA4fpHPF6xsUhRTfi5EEryspuBpe/QA4VWQOV1U=
 github.com/ncruces/sort v0.1.2/go.mod h1:vEJUTBJtebIuCMmXD18GKo5GJGhsay+xZFOoBEIXFmE=
 github.com/psanford/httpreadat v0.1.0 h1:VleW1HS2zO7/4c7c7zNl33fO6oYACSagjJIyMIwZLUE=
 github.com/psanford/httpreadat v0.1.0/go.mod h1:Zg7P+TlBm3bYbyHTKv/EdtSJZn3qwbPwpfZ/I9GKCRE=
-github.com/tetratelabs/wazero v1.8.1 h1:NrcgVbWfkWvVc4UtT4LRLDf91PsOzDzefMdwhLfA550=
-github.com/tetratelabs/wazero v1.8.1/go.mod h1:yAI0XTsMBhREkM/YDAK/zNou3GoiAce1P6+rp/wQhjs=
-golang.org/x/crypto v0.28.0 h1:GBDwsMXVQi34v5CCYUm2jkJvu4cbtru2U4TN2PSyQnw=
-golang.org/x/crypto v0.28.0/go.mod h1:rmgy+3RHxRZMyY0jjAJShp2zgEdOqj2AO7U0pYmeQ7U=
-golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
-golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
-golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
-golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+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/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
+golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
+golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
+golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+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=
 lukechampine.com/adiantum v1.1.1 h1:4fp6gTxWCqpEbLy40ExiYDDED3oUNWx5cTqBCtPdZqA=
 lukechampine.com/adiantum v1.1.1/go.mod h1:LrAYVnTYLnUtE/yMp5bQr0HstAf060YUF8nM0B6+rUw=

go.work

@@ -3,4 +3,5 @@ go 1.21
 use (
 	.
 	./gormlite
+	./embed/bcw2
 )

go.work.sum

@@ -1,3 +1,4 @@
+github.com/ncruces/go-sqlite3 v0.21.0/go.mod h1:zxMOaSG5kFYVFK4xQa0pdwIszqxqJ0W0BxBgwdrNjuA=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
@@ -9,5 +10,8 @@ golang.org/x/term v0.22.0/go.mod h1:F3qCibpT5AMpCRfhfT53vVJwhLtIVHhB9XDjfFvnMI4=
 golang.org/x/term v0.23.0/go.mod h1:DgV24QBUrK6jhZXl+20l6UWznPlwAHm1Q1mGHtydmSk=
 golang.org/x/term v0.24.0/go.mod h1:lOBK/LVxemqiMij05LGJ0tzNr8xlmwBRJ81PX6wVLH8=
 golang.org/x/term v0.25.0/go.mod h1:RPyXicDX+6vLxogjjRxjgD2TKtmAO6NZBsBRfrOLu7M=
+golang.org/x/term v0.26.0/go.mod h1:Si5m1o57C5nBNQo5z1iq+XDijt21BDBDp2bK0QI8e3E=
+golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
+golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=

gormlite/ddlmod.go

@@ -17,23 +17,11 @@ var (
 	indexRegexp        = regexp.MustCompile(fmt.Sprintf(`(?is)CREATE(?: UNIQUE)? INDEX [%v]?[\w\d-]+[%v]?(?s:.*?)ON (.*)$`, sqliteSeparator, sqliteSeparator))
 	tableRegexp        = regexp.MustCompile(fmt.Sprintf(`(?is)(CREATE TABLE [%v]?[\w\d-]+[%v]?)(?:\s*\((.*)\))?`, sqliteSeparator, sqliteSeparator))
 	separatorRegexp    = regexp.MustCompile(fmt.Sprintf("[%v]", sqliteSeparator))
-	columnsRegexp      = regexp.MustCompile(fmt.Sprintf(`[(,][%v]?(\w+)[%v]?`, sqliteSeparator, sqliteSeparator))
 	columnRegexp       = regexp.MustCompile(fmt.Sprintf(`^[%v]?([\w\d]+)[%v]?\s+([\w\(\)\d]+)(.*)$`, sqliteSeparator, sqliteSeparator))
 	defaultValueRegexp = regexp.MustCompile(`(?i) DEFAULT \(?(.+)?\)?( |COLLATE|GENERATED|$)`)
 	regRealDataType    = regexp.MustCompile(`[^\d](\d+)[^\d]?`)
 )
 
-func getAllColumns(s string) []string {
-	allMatches := columnsRegexp.FindAllStringSubmatch(s, -1)
-	columns := make([]string, 0, len(allMatches))
-	for _, matches := range allMatches {
-		if len(matches) > 1 {
-			columns = append(columns, matches[1])
-		}
-	}
-	return columns
-}
-
 type ddl struct {
 	head    string
 	fields  []string
@@ -110,9 +98,10 @@ func parseDDL(strs ...string) (*ddl, error) {
 				if strings.HasPrefix(fUpper, "CONSTRAINT") {
 					matches := uniqueRegexp.FindStringSubmatch(f)
 					if len(matches) > 0 {
-						if columns := getAllColumns(matches[1]); len(columns) == 1 {
+						cols, err := parseAllColumns(matches[1])
+						if err == nil && len(cols) == 1 {
 							for idx, column := range result.columns {
-								if column.NameValue.String == columns[0] {
+								if column.NameValue.String == cols[0] {
 									column.UniqueValue = sql.NullBool{Bool: true, Valid: true}
 									result.columns[idx] = column
 									break
@@ -123,12 +112,15 @@ func parseDDL(strs ...string) (*ddl, error) {
 					continue
 				}
 				if strings.HasPrefix(fUpper, "PRIMARY KEY") {
-					for _, name := range getAllColumns(f) {
-						for idx, column := range result.columns {
-							if column.NameValue.String == name {
-								column.PrimaryKeyValue = sql.NullBool{Bool: true, Valid: true}
-								result.columns[idx] = column
-								break
+					cols, err := parseAllColumns(f)
+					if err == nil {
+						for _, name := range cols {
+							for idx, column := range result.columns {
+								if column.NameValue.String == name {
+									column.PrimaryKeyValue = sql.NullBool{Bool: true, Valid: true}
+									result.columns[idx] = column
+									break
+								}
 							}
 						}
 					}

gormlite/ddlmod_parse_all_columns.go

@@ -0,0 +1,117 @@
+package gormlite
+
+import (
+	"errors"
+	"fmt"
+)
+
+type parseAllColumnsState int
+
+const (
+	parseAllColumnsState_NONE parseAllColumnsState = iota
+	parseAllColumnsState_Beginning
+	parseAllColumnsState_ReadingRawName
+	parseAllColumnsState_ReadingQuotedName
+	parseAllColumnsState_EndOfName
+	parseAllColumnsState_State_End
+)
+
+func parseAllColumns(in string) ([]string, error) {
+	s := []rune(in)
+	columns := make([]string, 0)
+	state := parseAllColumnsState_NONE
+	quote := rune(0)
+	name := make([]rune, 0)
+	for i := 0; i < len(s); i++ {
+		switch state {
+		case parseAllColumnsState_NONE:
+			if s[i] == '(' {
+				state = parseAllColumnsState_Beginning
+			}
+		case parseAllColumnsState_Beginning:
+			if isSpace(s[i]) {
+				continue
+			}
+			if isQuote(s[i]) {
+				state = parseAllColumnsState_ReadingQuotedName
+				quote = s[i]
+				continue
+			}
+			if s[i] == '[' {
+				state = parseAllColumnsState_ReadingQuotedName
+				quote = ']'
+				continue
+			} else if s[i] == ')' {
+				return columns, fmt.Errorf("unexpected token: %s", string(s[i]))
+			}
+			state = parseAllColumnsState_ReadingRawName
+			name = append(name, s[i])
+		case parseAllColumnsState_ReadingRawName:
+			if isSeparator(s[i]) {
+				state = parseAllColumnsState_Beginning
+				columns = append(columns, string(name))
+				name = make([]rune, 0)
+				continue
+			}
+			if s[i] == ')' {
+				state = parseAllColumnsState_State_End
+				columns = append(columns, string(name))
+			}
+			if isQuote(s[i]) {
+				return nil, fmt.Errorf("unexpected token: %s", string(s[i]))
+			}
+			if isSpace(s[i]) {
+				state = parseAllColumnsState_EndOfName
+				columns = append(columns, string(name))
+				name = make([]rune, 0)
+				continue
+			}
+			name = append(name, s[i])
+		case parseAllColumnsState_ReadingQuotedName:
+			if s[i] == quote {
+				// check if quote character is escaped
+				if i+1 < len(s) && s[i+1] == quote {
+					name = append(name, quote)
+					i++
+					continue
+				}
+				state = parseAllColumnsState_EndOfName
+				columns = append(columns, string(name))
+				name = make([]rune, 0)
+				continue
+			}
+			name = append(name, s[i])
+		case parseAllColumnsState_EndOfName:
+			if isSpace(s[i]) {
+				continue
+			}
+			if isSeparator(s[i]) {
+				state = parseAllColumnsState_Beginning
+				continue
+			}
+			if s[i] == ')' {
+				state = parseAllColumnsState_State_End
+				continue
+			}
+			return nil, fmt.Errorf("unexpected token: %s", string(s[i]))
+		case parseAllColumnsState_State_End:
+			break
+		}
+	}
+	if state != parseAllColumnsState_State_End {
+		return nil, errors.New("unexpected end")
+	}
+	return columns, nil
+}
+
+func isSpace(r rune) bool {
+	return r == ' ' || r == '\t'
+}
+
+func isQuote(r rune) bool {
+	return r == '`' || r == '"' || r == '\''
+}
+
+func isSeparator(r rune) bool {
+	return r == ','
+}

gormlite/ddlmod_parse_all_columns_test.go

@@ -0,0 +1,48 @@
+package gormlite
+
+import "testing"
+
+func TestParseAllColumns(t *testing.T) {
+	tc := []struct {
+		name     string
+		input    string
+		expected []string
+	}{
+		{
+			name:     "Simple case",
+			input:    "PRIMARY KEY (column1, column2)",
+			expected: []string{"column1", "column2"},
+		},
+		{
+			name:     "Quoted column name",
+			input:    "PRIMARY KEY (`column,xxx`, \"column 2\", \"column)3\", 'column''4', \"column\"\"5\")",
+			expected: []string{"column,xxx", "column 2", "column)3", "column'4", "column\"5"},
+		},
+		{
+			name:     "Japanese column name",
+			input:    "PRIMARY KEY (カラム1, `カラム2`)",
+			expected: []string{"カラム1", "カラム2"},
+		},
+		{
+			name:     "Column name quoted with []",
+			input:    "PRIMARY KEY ([column1], [column2])",
+			expected: []string{"column1", "column2"},
+		},
+	}
+	for _, tt := range tc {
+		t.Run(tt.name, func(t *testing.T) {
+			cols, err := parseAllColumns(tt.input)
+			if err != nil {
+				t.Errorf("Failed to parse columns: %s", err)
+			}
+			if len(cols) != len(tt.expected) {
+				t.Errorf("Expected %d columns, got %d", len(tt.expected), len(cols))
+			}
+			for i, col := range cols {
+				if col != tt.expected[i] {
+					t.Errorf("Expected %s, got %s", tt.expected[i], col)
+				}
+			}
+		})
+	}
+}

gormlite/download.sh

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

gormlite/error_translator.go

@@ -3,10 +3,12 @@ package gormlite
 import (
 	"errors"
 
-	"github.com/ncruces/go-sqlite3"
 	"gorm.io/gorm"
+
+	"github.com/ncruces/go-sqlite3"
 )
 
+// Translate it will translate the error to native gorm errors.
 func (_Dialector) Translate(err error) error {
 	switch {
 	case

gormlite/error_translator_test.go

@@ -3,9 +3,10 @@ package gormlite
 import (
 	"testing"
 
-	"github.com/ncruces/go-sqlite3/vfs/memdb"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
+
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
 func TestErrorTranslator(t *testing.T) {

gormlite/go.mod

@@ -5,7 +5,7 @@ go 1.21
 toolchain go1.23.0
 
 require (
-	github.com/ncruces/go-sqlite3 v0.18.4
+	github.com/ncruces/go-sqlite3 v0.21.3
 	gorm.io/gorm v1.25.12
 )
 
@@ -13,7 +13,7 @@ require (
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/ncruces/julianday v1.0.0 // indirect
-	github.com/tetratelabs/wazero v1.8.1 // indirect
-	golang.org/x/sys v0.26.0 // indirect
-	golang.org/x/text v0.19.0 // indirect
+	github.com/tetratelabs/wazero v1.8.2 // indirect
+	golang.org/x/sys v0.29.0 // indirect
+	golang.org/x/text v0.21.0 // indirect
 )

gormlite/go.sum

@@ -2,15 +2,15 @@ github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
 github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
-github.com/ncruces/go-sqlite3 v0.18.4 h1:Je8o3y33MDwPYY/Cacas8yCsuoUzpNY/AgoSlN2ekyE=
-github.com/ncruces/go-sqlite3 v0.18.4/go.mod h1:4HLag13gq1k10s4dfGBhMfRVsssJRT9/5hYqVM9RUYo=
+github.com/ncruces/go-sqlite3 v0.21.3 h1:hHkfNQLcbnxPJZhC/RGw9SwP3bfkv/Y0xUHWsr1CdMQ=
+github.com/ncruces/go-sqlite3 v0.21.3/go.mod h1:zxMOaSG5kFYVFK4xQa0pdwIszqxqJ0W0BxBgwdrNjuA=
 github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M=
 github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
-github.com/tetratelabs/wazero v1.8.1 h1:NrcgVbWfkWvVc4UtT4LRLDf91PsOzDzefMdwhLfA550=
-github.com/tetratelabs/wazero v1.8.1/go.mod h1:yAI0XTsMBhREkM/YDAK/zNou3GoiAce1P6+rp/wQhjs=
-golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
-golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
-golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+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=
 gorm.io/gorm v1.25.12 h1:I0u8i2hWQItBq1WfE0o2+WuL9+8L21K9e2HHSTE/0f8=
 gorm.io/gorm v1.25.12/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ=

gormlite/sqlite.go

@@ -14,6 +14,11 @@ import (
 	"github.com/ncruces/go-sqlite3/driver"
 )
 
+type _Dialector struct {
+	DSN  string
+	Conn gorm.ConnPool
+}
+
 // Open opens a GORM dialector from a data source name.
 func Open(dsn string) gorm.Dialector {
 	return &_Dialector{DSN: dsn}
@@ -24,11 +29,6 @@ func OpenDB(db gorm.ConnPool) gorm.Dialector {
 	return &_Dialector{Conn: db}
 }
 
-type _Dialector struct {
-	DSN  string
-	Conn gorm.ConnPool
-}
-
 func (dialector _Dialector) Name() string {
 	return "sqlite"
 }

internal/alloc/alloc_other.go

@@ -1,9 +1,24 @@
-//go:build !(unix || windows) || sqlite3_nosys
+//go:build !unix && !windows
 
 package alloc
 
 import "github.com/tetratelabs/wazero/experimental"
 
-func Virtual(cap, max uint64) experimental.LinearMemory {
-	return Slice(cap, max)
+func NewMemory(cap, max uint64) experimental.LinearMemory {
+	return &sliceMemory{make([]byte, 0, cap)}
+}
+
+type sliceMemory struct {
+	buf []byte
+}
+
+func (b *sliceMemory) Free() {}
+
+func (b *sliceMemory) Reallocate(size uint64) []byte {
+	if cap := uint64(cap(b.buf)); size > cap {
+		b.buf = append(b.buf[:cap], make([]byte, size-cap)...)
+	} else {
+		b.buf = b.buf[:size]
+	}
+	return b.buf
 }

internal/alloc/alloc_slice.go

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

internal/alloc/alloc_test.go

@@ -9,6 +9,6 @@ import (
 
 func TestVirtual(t *testing.T) {
 	defer func() { _ = recover() }()
-	alloc.Virtual(math.MaxInt+2, math.MaxInt+2)
+	alloc.NewMemory(math.MaxInt+2, math.MaxInt+2)
 	t.Error("want panic")
 }

internal/alloc/alloc_unix.go

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

internal/alloc/alloc_windows.go

@@ -1,5 +1,3 @@
-//go:build !sqlite3_nosys
-
 package alloc
 
 import (
@@ -11,7 +9,7 @@ import (
 	"golang.org/x/sys/windows"
 )
 
-func Virtual(_, max uint64) experimental.LinearMemory {
+func NewMemory(_, max uint64) experimental.LinearMemory {
 	// Round up to the page size.
 	rnd := uint64(windows.Getpagesize() - 1)
 	max = (max + rnd) &^ rnd

internal/dotlk/dotlk.go

@@ -0,0 +1,29 @@
+package dotlk
+
+import (
+	"errors"
+	"io/fs"
+	"os"
+)
+
+// LockShm creates a directory on disk to prevent SQLite
+// from using this path for a shared memory file.
+func LockShm(name string) error {
+	err := os.Mkdir(name, 0777)
+	if errors.Is(err, fs.ErrExist) {
+		s, err := os.Lstat(name)
+		if err == nil && s.IsDir() {
+			return nil
+		}
+	}
+	return err
+}
+
+// Unlock removes the lock or shared memory file.
+func Unlock(name string) error {
+	err := os.Remove(name)
+	if errors.Is(err, fs.ErrNotExist) {
+		return nil
+	}
+	return err
+}

internal/dotlk/dotlk_other.go

@@ -0,0 +1,13 @@
+//go:build !unix
+
+package dotlk
+
+import "os"
+
+// TryLock returns nil if it acquired the lock,
+// fs.ErrExist if another process has the lock.
+func TryLock(name string) error {
+	f, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0666)
+	f.Close()
+	return err
+}

internal/dotlk/dotlk_unix.go

@@ -0,0 +1,50 @@
+//go:build unix
+
+package dotlk
+
+import (
+	"errors"
+	"io/fs"
+	"os"
+	"strconv"
+
+	"golang.org/x/sys/unix"
+)
+
+// TryLock returns nil if it acquired the lock,
+// fs.ErrExist if another process has the lock.
+func TryLock(name string) error {
+	for retry := true; retry; retry = false {
+		f, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0666)
+		if err == nil {
+			f.WriteString(strconv.Itoa(os.Getpid()))
+			f.Close()
+			return nil
+		}
+		if !errors.Is(err, fs.ErrExist) {
+			return err
+		}
+		if !removeStale(name) {
+			break
+		}
+	}
+	return fs.ErrExist
+}
+
+func removeStale(name string) bool {
+	buf, err := os.ReadFile(name)
+	if err != nil {
+		return errors.Is(err, fs.ErrNotExist)
+	}
+
+	pid, err := strconv.Atoi(string(buf))
+	if err != nil {
+		return false
+	}
+	if unix.Kill(pid, 0) == nil {
+		return false
+	}
+
+	err = os.Remove(name)
+	return err == nil || errors.Is(err, fs.ErrNotExist)
+}

internal/testcfg/testcfg.go

@@ -1,30 +1,30 @@
 package testcfg
 
 import (
-	"math/bits"
 	"os"
 	"path/filepath"
 
-	"github.com/ncruces/go-sqlite3"
 	"github.com/tetratelabs/wazero"
+
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
 )
 
 // notest
 
 func init() {
-	if bits.UintSize < 64 {
-		return
+	if util.CompilerSupported() {
+		sqlite3.RuntimeConfig = wazero.NewRuntimeConfigCompiler()
+	} else {
+		sqlite3.RuntimeConfig = wazero.NewRuntimeConfigInterpreter()
 	}
-
-	sqlite3.RuntimeConfig = wazero.NewRuntimeConfig().
-		WithMemoryCapacityFromMax(true).
-		WithMemoryLimitPages(1024)
-
+	sqlite3.RuntimeConfig = sqlite3.RuntimeConfig.WithMemoryLimitPages(512)
 	if os.Getenv("CI") != "" {
 		path := filepath.Join(os.TempDir(), "wazero")
 		if err := os.MkdirAll(path, 0777); err == nil {
 			if cache, err := wazero.NewCompilationCacheWithDir(path); err == nil {
-				sqlite3.RuntimeConfig.WithCompilationCache(cache)
+				sqlite3.RuntimeConfig = sqlite3.RuntimeConfig.
+					WithCompilationCache(cache)
 			}
 		}
 	}

internal/util/bool.go

@@ -1,22 +0,0 @@
-package util
-
-import "strings"
-
-func ParseBool(s string) (b, ok bool) {
-	if len(s) == 0 {
-		return false, false
-	}
-	if s[0] == '0' {
-		return false, true
-	}
-	if '1' <= s[0] && s[0] <= '9' {
-		return true, true
-	}
-	switch strings.ToLower(s) {
-	case "true", "yes", "on":
-		return true, true
-	case "false", "no", "off":
-		return false, true
-	}
-	return false, false
-}

internal/util/bool_test.go

@@ -1,28 +0,0 @@
-package util
-
-import "testing"
-
-func TestParseBool(t *testing.T) {
-	tests := []struct {
-		str string
-		val bool
-		ok  bool
-	}{
-		{"", false, false},
-		{"0", false, true},
-		{"1", true, true},
-		{"9", true, true},
-		{"T", false, false},
-		{"true", true, true},
-		{"FALSE", false, true},
-		{"false?", false, false},
-	}
-	for _, tt := range tests {
-		t.Run(tt.str, func(t *testing.T) {
-			gotVal, gotOK := ParseBool(tt.str)
-			if gotVal != tt.val || gotOK != tt.ok {
-				t.Errorf("ParseBool(%q) = (%v, %v) want (%v, %v)", tt.str, gotVal, gotOK, tt.val, tt.ok)
-			}
-		})
-	}
-}

internal/util/compiler.go

@@ -0,0 +1,27 @@
+package util
+
+import (
+	"runtime"
+
+	"golang.org/x/sys/cpu"
+)
+
+func CompilerSupported() bool {
+	switch runtime.GOOS {
+	case "linux", "android",
+		"windows", "darwin",
+		"freebsd", "netbsd", "dragonfly",
+		"solaris", "illumos":
+		break
+	default:
+		return false
+	}
+	switch runtime.GOARCH {
+	case "amd64":
+		return cpu.X86.HasSSE41
+	case "arm64":
+		return true
+	default:
+		return false
+	}
+}

internal/util/math.go

@@ -0,0 +1,29 @@
+package util
+
+import "math"
+
+func abs(n int) int {
+	if n < 0 {
+		return -n
+	}
+	return n
+}
+
+func GCD(m, n int) int {
+	for n != 0 {
+		m, n = n, m%n
+	}
+	return abs(m)
+}
+
+func LCM(m, n int) int {
+	if n == 0 {
+		return 0
+	}
+	return abs(n) * (abs(m) / GCD(m, n))
+}
+
+// https://developer.nvidia.com/blog/lerp-faster-cuda/
+func Lerp(v0, v1, t float64) float64 {
+	return math.FMA(t, v1, math.FMA(-t, v0, v0))
+}

internal/util/math_test.go

@@ -1,4 +1,4 @@
-package adiantum
+package util
 
 import (
 	"math"
@@ -25,7 +25,7 @@ func Test_abs(t *testing.T) {
 	}
 }
 
-func Test_gcd(t *testing.T) {
+func Test_GCD(t *testing.T) {
 	tests := []struct {
 		arg1 int
 		arg2 int
@@ -46,14 +46,14 @@ func Test_gcd(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run("", func(t *testing.T) {
-			if got := gcd(tt.arg1, tt.arg2); got != tt.want {
+			if got := GCD(tt.arg1, tt.arg2); got != tt.want {
 				t.Errorf("gcd(%d, %d) = %d, want %d", tt.arg1, tt.arg2, got, tt.want)
 			}
 		})
 	}
 }
 
-func Test_lcm(t *testing.T) {
+func Test_LCM(t *testing.T) {
 	tests := []struct {
 		arg1 int
 		arg2 int
@@ -74,7 +74,7 @@ func Test_lcm(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run("", func(t *testing.T) {
-			if got := lcm(tt.arg1, tt.arg2); got != tt.want {
+			if got := LCM(tt.arg1, tt.arg2); got != tt.want {
 				t.Errorf("lcm(%d, %d) = %d, want %d", tt.arg1, tt.arg2, got, tt.want)
 			}
 		})

internal/util/mmap_other.go

@@ -1,22 +1,5 @@
-//go:build !unix || !(amd64 || arm64 || riscv64 || ppc64le) || sqlite3_noshm || sqlite3_nosys
+//go:build !unix
 
 package util
 
-import (
-	"context"
-
-	"github.com/ncruces/go-sqlite3/internal/alloc"
-	"github.com/tetratelabs/wazero/experimental"
-)
-
 type mmapState struct{}
-
-func withAllocator(ctx context.Context) context.Context {
-	return experimental.WithMemoryAllocator(ctx,
-		experimental.MemoryAllocatorFunc(func(cap, max uint64) experimental.LinearMemory {
-			if cap == max {
-				return alloc.Virtual(cap, max)
-			}
-			return alloc.Slice(cap, max)
-		}))
-}

internal/util/mmap_unix.go

@@ -1,4 +1,4 @@
-//go:build unix && (amd64 || arm64 || riscv64 || ppc64le) && !(sqlite3_noshm || sqlite3_nosys)
+//go:build unix
 
 package util
 
@@ -7,17 +7,10 @@ import (
 	"os"
 	"unsafe"
 
-	"github.com/ncruces/go-sqlite3/internal/alloc"
 	"github.com/tetratelabs/wazero/api"
-	"github.com/tetratelabs/wazero/experimental"
 	"golang.org/x/sys/unix"
 )
 
-func withAllocator(ctx context.Context) context.Context {
-	return experimental.WithMemoryAllocator(ctx,
-		experimental.MemoryAllocatorFunc(alloc.Virtual))
-}
-
 type mmapState struct {
 	regions []*MappedRegion
 }
@@ -46,13 +39,13 @@ func (s *mmapState) new(ctx context.Context, mod api.Module, size int32) *Mapped
 	// Save the newly allocated region.
 	ptr := uint32(stack[0])
 	buf := View(mod, ptr, uint64(size))
-	addr := unsafe.Pointer(&buf[0])
-	s.regions = append(s.regions, &MappedRegion{
+	res := &MappedRegion{
 		Ptr:  ptr,
-		addr: addr,
 		size: size,
-	})
-	return s.regions[len(s.regions)-1]
+		addr: unsafe.Pointer(&buf[0]),
+	}
+	s.regions = append(s.regions, res)
+	return res
 }
 
 type MappedRegion struct {
@@ -62,10 +55,10 @@ type MappedRegion struct {
 	used bool
 }
 
-func MapRegion(ctx context.Context, mod api.Module, f *os.File, offset int64, size int32, prot int) (*MappedRegion, error) {
+func MapRegion(ctx context.Context, mod api.Module, f *os.File, offset int64, size int32, readOnly bool) (*MappedRegion, error) {
 	s := ctx.Value(moduleKey{}).(*moduleState)
 	r := s.new(ctx, mod, size)
-	err := r.mmap(f, offset, prot)
+	err := r.mmap(f, offset, readOnly)
 	if err != nil {
 		return nil, err
 	}
@@ -82,7 +75,11 @@ func (r *MappedRegion) Unmap() error {
 	return err
 }
 
-func (r *MappedRegion) mmap(f *os.File, offset int64, prot int) error {
+func (r *MappedRegion) mmap(f *os.File, offset int64, readOnly bool) error {
+	prot := unix.PROT_READ
+	if !readOnly {
+		prot |= unix.PROT_WRITE
+	}
 	_, err := unix.MmapPtr(int(f.Fd()), offset, r.addr, uintptr(r.size),
 		prot, unix.MAP_SHARED|unix.MAP_FIXED)
 	r.used = err == nil

internal/util/mmap_windows.go

@@ -0,0 +1,51 @@
+package util
+
+import (
+	"context"
+	"os"
+	"reflect"
+	"unsafe"
+
+	"github.com/tetratelabs/wazero/api"
+	"golang.org/x/sys/windows"
+)
+
+type MappedRegion struct {
+	windows.Handle
+	Data []byte
+	addr uintptr
+}
+
+func MapRegion(ctx context.Context, mod api.Module, f *os.File, offset int64, size int32) (*MappedRegion, error) {
+	h, err := windows.CreateFileMapping(windows.Handle(f.Fd()), nil, windows.PAGE_READWRITE, 0, 0, nil)
+	if h == 0 {
+		return nil, err
+	}
+
+	a, err := windows.MapViewOfFile(h, windows.FILE_MAP_WRITE,
+		uint32(offset>>32), uint32(offset), uintptr(size))
+	if a == 0 {
+		windows.CloseHandle(h)
+		return nil, err
+	}
+
+	res := &MappedRegion{Handle: h, addr: a}
+	// SliceHeader, although deprecated, avoids a go vet warning.
+	sh := (*reflect.SliceHeader)(unsafe.Pointer(&res.Data))
+	sh.Len = int(size)
+	sh.Cap = int(size)
+	sh.Data = a
+	return res, nil
+}
+
+func (r *MappedRegion) Unmap() error {
+	if r.Data == nil {
+		return nil
+	}
+	err := windows.UnmapViewOfFile(r.addr)
+	if err != nil {
+		return err
+	}
+	r.Data = nil
+	return windows.CloseHandle(r.Handle)
+}

internal/util/module.go

@@ -4,8 +4,12 @@ import (
 	"context"
 
 	"github.com/tetratelabs/wazero/experimental"
+
+	"github.com/ncruces/go-sqlite3/internal/alloc"
 )
 
+type ConnKey struct{}
+
 type moduleKey struct{}
 type moduleState struct {
 	mmapState
@@ -14,7 +18,7 @@ type moduleState struct {
 
 func NewContext(ctx context.Context) context.Context {
 	state := new(moduleState)
-	ctx = withAllocator(ctx)
+	ctx = experimental.WithMemoryAllocator(ctx, experimental.MemoryAllocatorFunc(alloc.NewMemory))
 	ctx = experimental.WithCloseNotifier(ctx, state)
 	ctx = context.WithValue(ctx, moduleKey{}, state)
 	return ctx

internal/util/pointer_test.go

@@ -1,15 +1,13 @@
-package util_test
+package util
 
 import (
 	"math"
 	"testing"
-
-	"github.com/ncruces/go-sqlite3/internal/util"
 )
 
 func TestUnwrapPointer(t *testing.T) {
-	p := util.Pointer[float64]{Value: math.Pi}
-	if got := util.UnwrapPointer(p); got != math.Pi {
+	p := Pointer[float64]{Value: math.Pi}
+	if got := UnwrapPointer(p); got != math.Pi {
 		t.Errorf("want π, got %v", got)
 	}
 }

sqlite.go

@@ -9,11 +9,11 @@ import (
 	"sync"
 	"unsafe"
 
-	"github.com/ncruces/go-sqlite3/internal/util"
-	"github.com/ncruces/go-sqlite3/vfs"
 	"github.com/tetratelabs/wazero"
 	"github.com/tetratelabs/wazero/api"
-	"github.com/tetratelabs/wazero/experimental"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/ncruces/go-sqlite3/vfs"
 )
 
 // Configure SQLite Wasm.
@@ -48,11 +48,20 @@ func compileSQLite() {
 	ctx := context.Background()
 	cfg := RuntimeConfig
 	if cfg == nil {
-		cfg = wazero.NewRuntimeConfig()
+		if util.CompilerSupported() {
+			cfg = wazero.NewRuntimeConfigCompiler()
+		} else {
+			cfg = wazero.NewRuntimeConfigInterpreter()
+		}
+		if bits.UintSize < 64 {
+			cfg = cfg.WithMemoryLimitPages(512) // 32MB
+		} else {
+			cfg = cfg.WithMemoryLimitPages(4096) // 256MB
+		}
 	}
+	cfg = cfg.WithCoreFeatures(api.CoreFeaturesV2)
 
-	instance.runtime = wazero.NewRuntimeWithConfig(ctx,
-		cfg.WithCoreFeatures(api.CoreFeaturesV2|experimental.CoreFeaturesThreads))
+	instance.runtime = wazero.NewRuntimeWithConfig(ctx, cfg)
 
 	env := instance.runtime.NewHostModuleBuilder("env")
 	env = vfs.ExportHostFunctions(env)
@@ -259,10 +268,11 @@ func (a *arena) mark() (reset func()) {
 	ptrs := len(a.ptrs)
 	next := a.next
 	return func() {
-		for _, ptr := range a.ptrs[ptrs:] {
+		rest := a.ptrs[ptrs:]
+		for _, ptr := range a.ptrs[:ptrs] {
 			a.sqlt.free(ptr)
 		}
-		a.ptrs = a.ptrs[:ptrs]
+		a.ptrs = rest
 		a.next = next
 	}
 }

sqlite3/base64.patch

@@ -0,0 +1,11 @@
+--- ext/base64.c.orig
++++ ext/base64.c
+@@ -198,7 +198,7 @@
+       deliberate_fall_through; /* FALLTHRU */
+     case 1:
+       pOut[0] = (qv>>16) & 0xff;
+-      deliberate_fall_through; /* FALLTHRU */
++      break; /* FALLTHRU */
+     }
+     pOut += nbo;
+   }

sqlite3/busy_timeout.patch

@@ -1,8 +1,8 @@
-# Replace sqliteDefaultBusyCallback.
-# This patch allows Go to handle (and interrupt) sqlite3_busy_timeout.
+# Replace sqliteDefaultBusyCallback, so Go can
+# handle, and interrupt, sqlite3_busy_timeout.
 --- sqlite3.c.orig
 +++ sqlite3.c
-@@ -181614,7 +181614,7 @@
+@@ -183054,7 +183054,7 @@
    if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
  #endif
    if( ms>0 ){

sqlite3/column.c

@@ -38,6 +38,9 @@ int sqlite3_columns_go(sqlite3_stmt *stmt, int nCol, char *aType,
     }
     if (ptr == NULL && rc == SQLITE_OK) {
       rc = sqlite3_errcode(sqlite3_db_handle(stmt));
+      if (rc == SQLITE_ROW || rc == SQLITE_DONE) {
+        rc = SQLITE_OK;
+      }
     }
     aData[i].ptr = ptr;
     aData[i].len = sqlite3_column_bytes(stmt, i);

sqlite3/download.sh

@@ -3,34 +3,46 @@ set -euo pipefail
 
 cd -P -- "$(dirname -- "$0")"
 
-curl -#OL "https://sqlite.org/2024/sqlite-amalgamation-3460100.zip"
+curl -#OL "https://sqlite.org/2025/sqlite-amalgamation-3480000.zip"
 unzip -d . sqlite-amalgamation-*.zip
-mv sqlite-amalgamation-*/sqlite3* .
+mv sqlite-amalgamation-*/sqlite3.c .
+mv sqlite-amalgamation-*/sqlite3.h .
+mv sqlite-amalgamation-*/sqlite3ext.h .
 rm -rf sqlite-amalgamation-*
 
-cat *.patch | patch --no-backup-if-mismatch
+# To test a snapshot:
+# curl -# https://sqlite.org/snapshot/sqlite-snapshot-202410081727.tar.gz | tar xz
+# mv sqlite-snapshot-*/sqlite3.c .
+# mv sqlite-snapshot-*/sqlite3.h .
+# mv sqlite-snapshot-*/sqlite3ext.h .
+# rm -rf sqlite-snapshot-*
 
 mkdir -p ext/
 cd ext/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/anycollseq.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/base64.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/decimal.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/ieee754.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/regexp.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/series.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/spellfix.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/ext/misc/uint.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.48.0/ext/misc/anycollseq.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.48.0/ext/misc/base64.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.48.0/ext/misc/decimal.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.48.0/ext/misc/ieee754.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.48.0/ext/misc/regexp.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.48.0/ext/misc/series.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.48.0/ext/misc/spellfix.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.48.0/ext/misc/uint.c"
 cd ~-
 
 cd ../vfs/tests/mptest/testdata/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/mptest/mptest.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/mptest/config01.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/mptest/config02.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/mptest/crash01.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/mptest/crash02.subtest"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/mptest/multiwrite01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.48.0/mptest/config01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.48.0/mptest/config02.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.48.0/mptest/crash01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.48.0/mptest/crash02.subtest"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.48.0/mptest/multiwrite01.test"
 cd ~-
 
-cd ../vfs/tests/speedtest1/testdata/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.46.1/test/speedtest1.c"
-cd ~-
+cd ../vfs/tests/mptest/wasm/
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.48.0/mptest/mptest.c"
+cd ~-
+
+cd ../vfs/tests/speedtest1/wasm/
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.48.0/test/speedtest1.c"
+cd ~-
+
+cat *.patch | patch -p0 --no-backup-if-mismatch

sqlite3/long_double.patch

@@ -1,29 +0,0 @@
---- sqlite3.c.orig
-+++ sqlite3.c
-@@ -35561,7 +35561,7 @@
- 
-   if( e==0 ){
-     *pResult = s;
--  }else if( sqlite3Config.bUseLongDouble ){
-+  }else if( sizeof(LONGDOUBLE_TYPE)>8 && sqlite3Config.bUseLongDouble ){
-     LONGDOUBLE_TYPE r = (LONGDOUBLE_TYPE)s;
-     if( e>0 ){
-       while( e>=100  ){ e-=100; r *= 1.0e+100L; }
-@@ -35967,7 +35967,7 @@
-   /* Multiply r by powers of ten until it lands somewhere in between
-   ** 1.0e+19 and 1.0e+17.
-   */
--  if( sqlite3Config.bUseLongDouble ){
-+  if( sizeof(LONGDOUBLE_TYPE)>8 && sqlite3Config.bUseLongDouble ){
-     LONGDOUBLE_TYPE rr = r;
-     if( rr>=1.0e+19 ){
-       while( rr>=1.0e+119L ){ exp+=100; rr *= 1.0e-100L; }
-@@ -89354,7 +89354,7 @@
-     ** than NULL */
-     return 1;
-   }
--  if( sqlite3Config.bUseLongDouble ){
-+  if( sizeof(LONGDOUBLE_TYPE)>8 && sqlite3Config.bUseLongDouble ){
-     LONGDOUBLE_TYPE x = (LONGDOUBLE_TYPE)i;
-     testcase( x<r );
-     testcase( x>r );

sqlite3/sqlite_cfg.h

@@ -18,8 +18,6 @@
 #define HAVE_STDINT_H 1
 #define HAVE_INTTYPES_H 1
 
-#define LONGDOUBLE_TYPE double
-
 #define HAVE_LOG2 1
 #define HAVE_LOG10 1
 #define HAVE_ISNAN 1
@@ -35,10 +33,6 @@
 #define HAVE_MALLOC_H 1
 #define HAVE_MALLOC_USABLE_SIZE 1
 
-// Because Wasm does not support shared memory,
-// SQLite disables WAL for Wasm builds.
-#undef SQLITE_OMIT_WAL
-
 // Implemented in vfs.c.
 int localtime_s(struct tm *const pTm, time_t const *const pTime);