Stricter vtabs, sqlite-createtable-parser.

Bumps [golang.org/x/crypto](https://github.com/golang/crypto) from 0.46.0 to 0.47.0.
- [Commits](https://github.com/golang/crypto/compare/v0.46.0...v0.47.0)

---
updated-dependencies:
- dependency-name: golang.org/x/crypto
  dependency-version: 0.47.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/workflows/build-test.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-echo 'set -eu' > test.sh
+echo 'set -eux' > test.sh
 
 for p in $(go list ./...); do
   dir=".${p#github.com/ncruces/go-sqlite3}"

.github/workflows/libc.yml

@@ -10,12 +10,12 @@ jobs:
   test:
     strategy:
       matrix:
-        os: [ubuntu-24.04, ubuntu-24.04-arm, macos-13, macos-15]
+        os: [ubuntu-24.04, ubuntu-24.04-arm, macos-15, macos-15-intel]
     runs-on: ${{ matrix.os }}
 
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-go@v5
+    - uses: actions/checkout@v6
+    - uses: actions/setup-go@v6
       with: { go-version: stable }
 
     - name: Benchmark

.github/workflows/repro.yml

@@ -17,13 +17,13 @@ jobs:
 
     steps:
     - uses: ilammy/msvc-dev-cmd@v1
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
 
     - name: Build
       shell: bash
       run: .github/workflows/repro.sh
 
-    - uses: actions/attest-build-provenance@v2
+    - uses: actions/attest-build-provenance@v3
       if: matrix.os == 'ubuntu-latest'
       with:
         subject-path: |

.github/workflows/test.yml

@@ -30,8 +30,8 @@ jobs:
       contents: write
 
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-go@v5
+    - uses: actions/checkout@v6
+    - uses: actions/setup-go@v6
       with: { go-version: stable }
 
     - name: Format
@@ -51,30 +51,30 @@ jobs:
       run: go vet ./...
 
     - name: Build
-      run: go build -v ./...
+      run: go build ./...
 
     - name: Test
-      run: go test -v ./... -bench . -benchtime=1x
+      run: go test ./... -bench . -benchtime=1x
 
     - name: Test BSD locks
-      run: go test -v -tags sqlite3_flock ./...
+      run: go test -tags sqlite3_flock ./...
       if: matrix.os != 'windows-latest'
 
     - name: Test dot locks
-      run: go test -v -tags sqlite3_dotlk ./...
+      run: go test -tags sqlite3_dotlk ./...
       if: matrix.os != 'windows-latest'
 
     - name: Test modules
       shell: bash
       run: |
         go work init .
-        go work use -r embed gormlite
-        go test -v ./embed/bcw2/...
+        go work use -r embed/bcw2 gormlite
+        go test ./embed/bcw2 ./gormlite
 
     - name: Test GORM
       shell: bash
       run: gormlite/test.sh
-      if: matrix.os != 'windows-latest'
+      if: matrix.os == 'ubuntu-latest'
 
     - name: Collect coverage
       run: |
@@ -93,44 +93,45 @@ jobs:
         github.event_name == 'push' &&
         matrix.os == 'ubuntu-latest'
 
-  test-bsd:
+  test-cross:
     strategy:
       matrix:
         os:
           - name: freebsd
-            version: '14.2'
-            flags: '-test.v'
+            version: '15.0'
           - name: netbsd
             version: '10.1'
-            flags: '-test.v'
+          - name: illumos
+            action: omnios
+            version: 'r151056'
+          - name: openbsd
+            version: '7.8'
+            tflags: '-test.short'
           - name: freebsd
             arch: arm64
-            version: '14.2'
-            flags: '-test.v -test.short'
+            version: '15.0'
+            tflags: '-test.short'
           - name: netbsd
             arch: arm64
             version: '10.1'
-            flags: '-test.v -test.short'
-          - name: openbsd
-            version: '7.7'
-            flags: '-test.v -test.short'
+            tflags: '-test.short'
     runs-on: ubuntu-latest
     needs: test
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
 
     - name: Build
       env:
         GOOS: ${{ matrix.os.name }}
         GOARCH: ${{ matrix.os.arch }}
-        TESTFLAGS: ${{ matrix.os.flags }}
+        TESTFLAGS: ${{ matrix.os.tflags }}
       run: .github/workflows/build-test.sh
 
     - name: Test
-      uses: cross-platform-actions/action@v0.28.0
+      uses: cross-platform-actions/action@v0.32.0
       with:
-        operating_system: ${{ matrix.os.name }}
+        operating_system: ${{ matrix.os.action || matrix.os.name }}
         architecture: ${{ matrix.os.arch }}
         version: ${{ matrix.os.version }}
         shell: bash
@@ -143,19 +144,16 @@ jobs:
         os:
           - name: dragonfly
             action: 'vmactions/dragonflybsd-vm@v1'
-            tflags: '-test.v'
           - name: illumos
-            action: 'vmactions/omnios-vm@v1'
-            tflags: '-test.v'
+            action: 'vmactions/openindiana-vm@v0'
           - 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
+    - uses: actions/checkout@v6
 
     - name: Build
       env:
@@ -174,8 +172,8 @@ jobs:
 
     steps:
     - uses: bytecodealliance/actions/wasmtime/setup@v1
-    - uses: actions/checkout@v4
-    - uses: actions/setup-go@v5
+    - uses: actions/checkout@v6
+    - uses: actions/setup-go@v6
       with: { go-version: stable }
 
     - name: Set path
@@ -187,7 +185,7 @@ jobs:
         GOARCH: wasm
         GOWASIRUNTIME: wasmtime
         GOWASIRUNTIMEARGS: '--env CI=true'
-      run: go test -v -short -tags sqlite3_dotlk -skip Example ./...
+      run: go test -short -tags sqlite3_dotlk -skip Example ./...
 
   test-qemu:
     runs-on: ubuntu-latest
@@ -195,42 +193,60 @@ jobs:
 
     steps:
     - uses: docker/setup-qemu-action@v3
-    - uses: actions/checkout@v4
-    - uses: actions/setup-go@v5
+    - uses: actions/checkout@v6
+    - uses: actions/setup-go@v6
       with: { go-version: stable }
 
     - name: Test 386 (32-bit)
-      run: GOARCH=386 go test -v -short ./...
+      run: GOARCH=386 go test -short ./...
 
     - name: Test riscv64 (interpreter)
-      run: GOARCH=riscv64 go test -v -short ./...
+      run: GOARCH=riscv64 go test -short ./...
 
     - name: Test ppc64le (interpreter)
-      run: GOARCH=ppc64le go test -v -short ./...
+      run: GOARCH=ppc64le go test -short ./...
+
+    - name: Test loong64 (interpreter)
+      run: GOARCH=loong64 go test -short ./...
 
     - name: Test s390x (big-endian)
-      run: GOARCH=s390x go test -v -short -tags sqlite3_dotlk ./...
+      run: GOARCH=s390x go test -short -tags sqlite3_dotlk ./...
 
   test-linuxarm:
     runs-on: ubuntu-24.04-arm
     needs: test
 
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-go@v5
+    - uses: actions/checkout@v6
+    - uses: actions/setup-go@v6
       with: { go-version: stable }
 
     - name: Test
-      run: go test -v ./...
+      run: go test ./...
+
+    - name: Test arm (32-bit)
+      run: GOARCH=arm GOARM=7 go test -short ./...
 
   test-macintel:
-    runs-on: macos-13
+    runs-on: macos-15-intel
     needs: test
 
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-go@v5
+    - uses: actions/checkout@v6
+    - uses: actions/setup-go@v6
       with: { go-version: stable }
 
     - name: Test
-      run: go test -v ./...
+      run: go test ./...
+
+  test-winarm:
+    runs-on: windows-11-arm
+    needs: test
+
+    steps:
+    - uses: actions/checkout@v6
+    - uses: actions/setup-go@v6
+      with: { go-version: stable }
+
+    - name: Test
+      run: go test ./...

README.md

@@ -84,14 +84,14 @@ It also benefits greatly from [SQLite's](https://sqlite.org/testing.html) and
 thorough testing.
 
 Every commit is tested on:
-* Linux: amd64, arm64, 386, riscv64, ppc64le, s390x
+* Linux: amd64, arm64, 386, arm, riscv64, ppc64le, loong64, s390x
 * macOS: amd64, arm64
-* Windows: amd64
+* Windows: amd64, arm64
 * BSD:
   * FreeBSD: amd64, arm64
-  * OpenBSD: amd64
   * NetBSD: amd64, arm64
   * DragonFly BSD: amd64
+  * OpenBSD: amd64
 * illumos: amd64
 * Solaris: amd64
 

config.go

@@ -157,16 +157,20 @@ func (c *Conn) FileControl(schema string, op FcntlOpcode, arg ...any) (any, erro
 			stk_t(op), stk_t(ptr)))
 		ret = util.Read32[vfs.LockLevel](c.mod, ptr)
 
-	case FCNTL_VFS_POINTER:
+	case FCNTL_VFSNAME, FCNTL_VFS_POINTER:
 		rc = res_t(c.call("sqlite3_file_control",
 			stk_t(c.handle), stk_t(schemaPtr),
-			stk_t(op), stk_t(ptr)))
+			stk_t(FCNTL_VFS_POINTER), stk_t(ptr)))
 		if rc == _OK {
 			const zNameOffset = 16
 			ptr = util.Read32[ptr_t](c.mod, ptr)
 			ptr = util.Read32[ptr_t](c.mod, ptr+zNameOffset)
 			name := util.ReadString(c.mod, ptr, _MAX_NAME)
-			ret = vfs.Find(name)
+			if op == FCNTL_VFS_POINTER {
+				ret = vfs.Find(name)
+			} else {
+				ret = name
+			}
 		}
 
 	case FCNTL_FILE_POINTER, FCNTL_JOURNAL_POINTER:
@@ -265,7 +269,7 @@ func traceCallback(ctx context.Context, mod api.Module, evt TraceEvent, pDB, pAr
 			}
 		}
 		if arg1 != nil {
-			_, rc = errorCode(c.trace(evt, arg1, arg2), ERROR)
+			_ = c.trace(evt, arg1, arg2)
 		}
 	}
 	return rc

conn.go

@@ -420,21 +420,21 @@ func busyCallback(ctx context.Context, mod api.Module, pDB ptr_t, count int32) (
 // Status retrieves runtime status information about a database connection.
 //
 // https://sqlite.org/c3ref/db_status.html
-func (c *Conn) Status(op DBStatus, reset bool) (current, highwater int, err error) {
+func (c *Conn) Status(op DBStatus, reset bool) (current, highwater int64, err error) {
 	defer c.arena.mark()()
-	hiPtr := c.arena.new(intlen)
-	curPtr := c.arena.new(intlen)
+	hiPtr := c.arena.new(8)
+	curPtr := c.arena.new(8)
 
 	var i int32
 	if reset {
 		i = 1
 	}
 
-	rc := res_t(c.call("sqlite3_db_status", stk_t(c.handle),
+	rc := res_t(c.call("sqlite3_db_status64", stk_t(c.handle),
 		stk_t(op), stk_t(curPtr), stk_t(hiPtr), stk_t(i)))
 	if err = c.error(rc); err == nil {
-		current = int(util.Read32[int32](c.mod, curPtr))
-		highwater = int(util.Read32[int32](c.mod, hiPtr))
+		current = util.Read64[int64](c.mod, curPtr)
+		highwater = util.Read64[int64](c.mod, hiPtr)
 	}
 	return
 }
@@ -444,20 +444,27 @@ func (c *Conn) Status(op DBStatus, reset bool) (current, highwater int, err erro
 // https://sqlite.org/c3ref/table_column_metadata.html
 func (c *Conn) TableColumnMetadata(schema, table, column string) (declType, collSeq string, notNull, primaryKey, autoInc bool, err error) {
 	defer c.arena.mark()()
-
-	var schemaPtr, columnPtr ptr_t
-	declTypePtr := c.arena.new(ptrlen)
-	collSeqPtr := c.arena.new(ptrlen)
-	notNullPtr := c.arena.new(ptrlen)
-	autoIncPtr := c.arena.new(ptrlen)
-	primaryKeyPtr := c.arena.new(ptrlen)
+	var (
+		declTypePtr   ptr_t
+		collSeqPtr    ptr_t
+		notNullPtr    ptr_t
+		primaryKeyPtr ptr_t
+		autoIncPtr    ptr_t
+		columnPtr     ptr_t
+		schemaPtr     ptr_t
+	)
+	if column != "" {
+		declTypePtr = c.arena.new(ptrlen)
+		collSeqPtr = c.arena.new(ptrlen)
+		notNullPtr = c.arena.new(ptrlen)
+		primaryKeyPtr = c.arena.new(ptrlen)
+		autoIncPtr = c.arena.new(ptrlen)
+		columnPtr = c.arena.string(column)
+	}
 	if schema != "" {
 		schemaPtr = c.arena.string(schema)
 	}
 	tablePtr := c.arena.string(table)
-	if column != "" {
-		columnPtr = c.arena.string(column)
-	}
 
 	rc := res_t(c.call("sqlite3_table_column_metadata", stk_t(c.handle),
 		stk_t(schemaPtr), stk_t(tablePtr), stk_t(columnPtr),

const.go

@@ -73,6 +73,9 @@ const (
 	ERROR_MISSING_COLLSEQ   ExtendedErrorCode = xErrorCode(ERROR) | (1 << 8)
 	ERROR_RETRY             ExtendedErrorCode = xErrorCode(ERROR) | (2 << 8)
 	ERROR_SNAPSHOT          ExtendedErrorCode = xErrorCode(ERROR) | (3 << 8)
+	ERROR_RESERVESIZE       ExtendedErrorCode = xErrorCode(ERROR) | (4 << 8)
+	ERROR_KEY               ExtendedErrorCode = xErrorCode(ERROR) | (5 << 8)
+	ERROR_UNABLE            ExtendedErrorCode = xErrorCode(ERROR) | (6 << 8)
 	IOERR_READ              ExtendedErrorCode = xErrorCode(IOERR) | (1 << 8)
 	IOERR_SHORT_READ        ExtendedErrorCode = xErrorCode(IOERR) | (2 << 8)
 	IOERR_WRITE             ExtendedErrorCode = xErrorCode(IOERR) | (3 << 8)
@@ -107,6 +110,8 @@ const (
 	IOERR_DATA              ExtendedErrorCode = xErrorCode(IOERR) | (32 << 8)
 	IOERR_CORRUPTFS         ExtendedErrorCode = xErrorCode(IOERR) | (33 << 8)
 	IOERR_IN_PAGE           ExtendedErrorCode = xErrorCode(IOERR) | (34 << 8)
+	IOERR_BADKEY            ExtendedErrorCode = xErrorCode(IOERR) | (35 << 8)
+	IOERR_CODEC             ExtendedErrorCode = xErrorCode(IOERR) | (36 << 8)
 	LOCKED_SHAREDCACHE      ExtendedErrorCode = xErrorCode(LOCKED) | (1 << 8)
 	LOCKED_VTAB             ExtendedErrorCode = xErrorCode(LOCKED) | (2 << 8)
 	BUSY_RECOVERY           ExtendedErrorCode = xErrorCode(BUSY) | (1 << 8)
@@ -168,7 +173,7 @@ const (
 
 // PrepareFlag is a flag that can be passed to [Conn.PrepareFlags].
 //
-// https://sqlite.org/c3ref/c_prepare_normalize.html
+// https://sqlite.org/c3ref/c_prepare_dont_log.html
 type PrepareFlag uint32
 
 const (
@@ -176,6 +181,7 @@ const (
 	PREPARE_NORMALIZE  PrepareFlag = 0x02
 	PREPARE_NO_VTAB    PrepareFlag = 0x04
 	PREPARE_DONT_LOG   PrepareFlag = 0x10
+	PREPARE_FROM_DDL   PrepareFlag = 0x20
 )
 
 // FunctionFlag is a flag that can be passed to
@@ -229,7 +235,8 @@ const (
 	DBSTATUS_DEFERRED_FKS        DBStatus = 10
 	DBSTATUS_CACHE_USED_SHARED   DBStatus = 11
 	DBSTATUS_CACHE_SPILL         DBStatus = 12
-	// DBSTATUS_MAX              DBStatus = 12
+	DBSTATUS_TEMPBUF_SPILL       DBStatus = 13
+	// DBSTATUS_MAX              DBStatus = 13
 )
 
 // DBConfig are the available database connection configuration options.
@@ -274,6 +281,7 @@ const (
 	FCNTL_CHUNK_SIZE          FcntlOpcode = 6
 	FCNTL_FILE_POINTER        FcntlOpcode = 7
 	FCNTL_PERSIST_WAL         FcntlOpcode = 10
+	FCNTL_VFSNAME             FcntlOpcode = 12
 	FCNTL_POWERSAFE_OVERWRITE FcntlOpcode = 13
 	FCNTL_VFS_POINTER         FcntlOpcode = 27
 	FCNTL_JOURNAL_POINTER     FcntlOpcode = 28
@@ -301,6 +309,7 @@ const (
 	LIMIT_VARIABLE_NUMBER     LimitCategory = 9
 	LIMIT_TRIGGER_DEPTH       LimitCategory = 10
 	LIMIT_WORKER_THREADS      LimitCategory = 11
+	LIMIT_PARSER_DEPTH        LimitCategory = 12
 )
 
 // AuthorizerActionCode are the integer action codes
@@ -362,13 +371,14 @@ const (
 // CheckpointMode are all the checkpoint mode values.
 //
 // https://sqlite.org/c3ref/c_checkpoint_full.html
-type CheckpointMode uint32
+type CheckpointMode int32
 
 const (
-	CHECKPOINT_PASSIVE  CheckpointMode = 0 /* Do as much as possible w/o blocking */
-	CHECKPOINT_FULL     CheckpointMode = 1 /* Wait for writers, then checkpoint */
-	CHECKPOINT_RESTART  CheckpointMode = 2 /* Like FULL but wait for readers */
-	CHECKPOINT_TRUNCATE CheckpointMode = 3 /* Like RESTART but also truncate WAL */
+	CHECKPOINT_NOOP     CheckpointMode = -1 /* Do no work at all */
+	CHECKPOINT_PASSIVE  CheckpointMode = 0  /* Do as much as possible w/o blocking */
+	CHECKPOINT_FULL     CheckpointMode = 1  /* Wait for writers, then checkpoint */
+	CHECKPOINT_RESTART  CheckpointMode = 2  /* Like FULL but wait for readers */
+	CHECKPOINT_TRUNCATE CheckpointMode = 3  /* Like RESTART but also truncate WAL */
 )
 
 // TxnState are the allowed return values from [Conn.TxnState].

context.go

@@ -1,7 +1,6 @@
 package sqlite3
 
 import (
-	"encoding/json"
 	"errors"
 	"math"
 	"time"
@@ -173,21 +172,6 @@ func (ctx Context) ResultPointer(ptr any) {
 		stk_t(ctx.handle), stk_t(valPtr))
 }
 
-// ResultJSON sets the result of the function to the JSON encoding of value.
-//
-// https://sqlite.org/c3ref/result_blob.html
-func (ctx Context) ResultJSON(value any) {
-	err := json.NewEncoder(callbackWriter(func(p []byte) (int, error) {
-		ctx.ResultRawText(p[:len(p)-1]) // remove the newline
-		return 0, nil
-	})).Encode(value)
-
-	if err != nil {
-		ctx.ResultError(err)
-		return // notest
-	}
-}
-
 // ResultValue sets the result of the function to a copy of [Value].
 //
 // https://sqlite.org/c3ref/result_blob.html
@@ -214,14 +198,14 @@ func (ctx Context) ResultError(err error) {
 		return
 	}
 
-	msg, code := errorCode(err, _OK)
+	msg, code := errorCode(err, ERROR)
 	if msg != "" {
 		defer ctx.c.arena.mark()()
 		ptr := ctx.c.arena.string(msg)
 		ctx.c.call("sqlite3_result_error",
 			stk_t(ctx.handle), stk_t(ptr), stk_t(len(msg)))
 	}
-	if code != _OK {
+	if code != res_t(ERROR) {
 		ctx.c.call("sqlite3_result_error_code",
 			stk_t(ctx.handle), stk_t(code))
 	}

driver/driver.go

@@ -263,10 +263,8 @@ func (n *connector) Connect(ctx context.Context) (ret driver.Conn, err error) {
 			return nil, err
 		}
 		defer s.Close()
-		if s.Step() && s.ColumnBool(0) {
-			c.readOnly = '1'
-		} else {
-			c.readOnly = '0'
+		if s.Step() {
+			c.readOnly = s.ColumnBool(0)
 		}
 		err = s.Close()
 		if err != nil {
@@ -322,7 +320,7 @@ type conn struct {
 	txReset  string
 	tmRead   sqlite3.TimeFormat
 	tmWrite  sqlite3.TimeFormat
-	readOnly byte
+	readOnly bool
 }
 
 var (
@@ -358,9 +356,9 @@ func (c *conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, e
 
 	c.txReset = ``
 	txBegin := `BEGIN ` + txLock
-	if opts.ReadOnly {
+	if opts.ReadOnly && !c.readOnly {
 		txBegin += ` ; PRAGMA query_only=on`
-		c.txReset = `; PRAGMA query_only=` + string(c.readOnly)
+		c.txReset = `; PRAGMA query_only=off`
 	}
 
 	if old := c.Conn.SetInterrupt(ctx); old != ctx {
@@ -604,26 +602,27 @@ func (r resultRowsAffected) RowsAffected() (int64, error) {
 	return int64(r), nil
 }
 
-type rows struct {
-	ctx context.Context
-	*stmt
-	names []string
-	types []string
-	nulls []bool
-	scans []scantype
-}
-
 type scantype byte
 
 const (
-	_ANY  scantype = iota
-	_INT  scantype = scantype(sqlite3.INTEGER)
-	_REAL scantype = scantype(sqlite3.FLOAT)
-	_TEXT scantype = scantype(sqlite3.TEXT)
-	_BLOB scantype = scantype(sqlite3.BLOB)
-	_NULL scantype = scantype(sqlite3.NULL)
-	_BOOL scantype = iota
+	_ANY scantype = iota
+	_INT
+	_REAL
+	_TEXT
+	_BLOB
+	_NULL
+	_BOOL
 	_TIME
+	_NOT_NULL
+)
+
+var (
+	_ [0]struct{} = [scantype(sqlite3.INTEGER) - _INT]struct{}{}
+	_ [0]struct{} = [scantype(sqlite3.FLOAT) - _REAL]struct{}{}
+	_ [0]struct{} = [scantype(sqlite3.TEXT) - _TEXT]struct{}{}
+	_ [0]struct{} = [scantype(sqlite3.BLOB) - _BLOB]struct{}{}
+	_ [0]struct{} = [scantype(sqlite3.NULL) - _NULL]struct{}{}
+	_ [0]struct{} = [_NOT_NULL & (_NOT_NULL - 1)]struct{}{}
 )
 
 func scanFromDecl(decl string) scantype {
@@ -648,6 +647,14 @@ func scanFromDecl(decl string) scantype {
 	return _ANY
 }
 
+type rows struct {
+	ctx context.Context
+	*stmt
+	names []string
+	types []string
+	scans []scantype
+}
+
 var (
 	// Ensure these interfaces are implemented:
 	_ driver.RowsColumnTypeDatabaseTypeName = &rows{}
@@ -674,34 +681,42 @@ func (r *rows) Columns() []string {
 
 func (r *rows) scanType(index int) scantype {
 	if r.scans == nil {
-		count := r.Stmt.ColumnCount()
+		count := len(r.names)
 		scans := make([]scantype, count)
 		for i := range scans {
 			scans[i] = scanFromDecl(strings.ToUpper(r.Stmt.ColumnDeclType(i)))
 		}
 		r.scans = scans
 	}
-	return r.scans[index]
+	return r.scans[index] &^ _NOT_NULL
 }
 
 func (r *rows) loadColumnMetadata() {
-	if r.nulls == nil {
+	if r.types == nil {
 		c := r.Stmt.Conn()
-		count := r.Stmt.ColumnCount()
-		nulls := make([]bool, count)
+		count := len(r.names)
 		types := make([]string, count)
 		scans := make([]scantype, count)
-		for i := range nulls {
-			if col := r.Stmt.ColumnOriginName(i); col != "" {
-				types[i], _, nulls[i], _, _, _ = c.TableColumnMetadata(
+		for i := range types {
+			var declType string
+			var notNull, autoInc bool
+			if column := r.Stmt.ColumnOriginName(i); column != "" {
+				declType, _, notNull, _, autoInc, _ = c.TableColumnMetadata(
 					r.Stmt.ColumnDatabaseName(i),
 					r.Stmt.ColumnTableName(i),
-					col)
-				types[i] = strings.ToUpper(types[i])
-				scans[i] = scanFromDecl(types[i])
+					column)
+			} else {
+				declType = r.Stmt.ColumnDeclType(i)
+			}
+			if declType != "" {
+				declType = strings.ToUpper(declType)
+				scans[i] = scanFromDecl(declType)
+				types[i] = declType
+			}
+			if notNull || autoInc {
+				scans[i] |= _NOT_NULL
 			}
 		}
-		r.nulls = nulls
 		r.types = types
 		r.scans = scans
 	}
@@ -720,15 +735,13 @@ func (r *rows) ColumnTypeDatabaseTypeName(index int) string {
 
 func (r *rows) ColumnTypeNullable(index int) (nullable, ok bool) {
 	r.loadColumnMetadata()
-	if r.nulls[index] {
-		return false, true
-	}
-	return true, false
+	nullable = r.scans[index]&^_NOT_NULL == 0
+	return nullable, !nullable
 }
 
 func (r *rows) ColumnTypeScanType(index int) (typ reflect.Type) {
 	r.loadColumnMetadata()
-	scan := r.scans[index]
+	scan := r.scans[index] &^ _NOT_NULL
 
 	if r.Stmt.Busy() {
 		// SQLite is dynamically typed and we now have a row.
@@ -740,7 +753,7 @@ func (r *rows) ColumnTypeScanType(index int) (typ reflect.Type) {
 		switch {
 		case scan == _TIME && val != _BLOB && val != _NULL:
 			t := r.Stmt.ColumnTime(index, r.tmRead)
-			useValType = t == time.Time{}
+			useValType = t.IsZero()
 		case scan == _BOOL && val == _INT:
 			i := r.Stmt.ColumnInt64(index)
 			useValType = i != 0 && i != 1
@@ -789,18 +802,7 @@ func (r *rows) Next(dest []driver.Value) error {
 	}
 	for i := range dest {
 		scan := r.scanType(i)
-		switch v := dest[i].(type) {
-		case int64:
-			if scan == _BOOL {
-				switch v {
-				case 1:
-					dest[i] = true
-				case 0:
-					dest[i] = false
-				}
-				continue
-			}
-		case []byte:
+		if v, ok := dest[i].([]byte); ok {
 			if len(v) == cap(v) { // a BLOB
 				continue
 			}
@@ -815,16 +817,19 @@ func (r *rows) Next(dest []driver.Value) error {
 				}
 			}
 			dest[i] = string(v)
-		case float64:
-			break
-		default:
-			continue
 		}
-		if scan == _TIME {
+		switch scan {
+		case _TIME:
 			t, err := r.tmRead.Decode(dest[i])
 			if err == nil {
 				dest[i] = t
-				continue
+			}
+		case _BOOL:
+			switch dest[i] {
+			case int64(0):
+				dest[i] = false
+			case int64(1):
+				dest[i] = true
 			}
 		}
 	}

driver/driver_test.go

@@ -33,7 +33,7 @@ func Test_Open_error(t *testing.T) {
 func Test_Open_dir(t *testing.T) {
 	t.Parallel()
 
-	db, err := sql.Open("sqlite3", ".")
+	db, err := Open(".")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -43,18 +43,18 @@ func Test_Open_dir(t *testing.T) {
 	if err == nil {
 		t.Fatal("want error")
 	}
-	if !errors.Is(err, sqlite3.CANTOPEN) {
-		t.Errorf("got %v, want sqlite3.CANTOPEN", err)
+	if !errors.Is(err, sqlite3.CANTOPEN_ISDIR) {
+		t.Errorf("got %v, want sqlite3.CANTOPEN_ISDIR", err)
 	}
 }
 
 func Test_Open_pragma(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t, url.Values{
+	dsn := memdb.TestDB(t, url.Values{
 		"_pragma": {"busy_timeout(1000)"},
 	})
 
-	db, err := sql.Open("sqlite3", tmp)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -72,11 +72,11 @@ func Test_Open_pragma(t *testing.T) {
 
 func Test_Open_pragma_invalid(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t, url.Values{
+	dsn := memdb.TestDB(t, url.Values{
 		"_pragma": {"busy_timeout 1000"},
 	})
 
-	db, err := sql.Open("sqlite3", tmp)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -100,12 +100,12 @@ func Test_Open_pragma_invalid(t *testing.T) {
 
 func Test_Open_txLock(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t, url.Values{
+	dsn := memdb.TestDB(t, url.Values{
 		"_txlock": {"exclusive"},
 		"_pragma": {"busy_timeout(1000)"},
 	})
 
-	db, err := sql.Open("sqlite3", tmp)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -136,11 +136,11 @@ func Test_Open_txLock(t *testing.T) {
 
 func Test_Open_txLock_invalid(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t, url.Values{
+	dsn := memdb.TestDB(t, url.Values{
 		"_txlock": {"xclusive"},
 	})
 
-	_, err := sql.Open("sqlite3", tmp+"_txlock=xclusive")
+	_, err := Open(dsn)
 	if err == nil {
 		t.Fatal("want error")
 	}
@@ -151,31 +151,28 @@ func Test_Open_txLock_invalid(t *testing.T) {
 
 func Test_BeginTx(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t, url.Values{
+	dsn := memdb.TestDB(t, url.Values{
 		"_txlock": {"exclusive"},
 		"_pragma": {"busy_timeout(0)"},
 	})
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	db, err := sql.Open("sqlite3", tmp)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db.Close()
 
-	_, err = db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted})
+	_, err = db.BeginTx(t.Context(), &sql.TxOptions{Isolation: sql.LevelReadCommitted})
 	if err.Error() != string(util.IsolationErr) {
 		t.Error("want isolationErr")
 	}
 
-	tx1, err := db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
+	tx1, err := db.BeginTx(t.Context(), &sql.TxOptions{ReadOnly: true})
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	tx2, err := db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
+	tx2, err := db.BeginTx(t.Context(), &sql.TxOptions{ReadOnly: true})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -201,9 +198,9 @@ func Test_BeginTx(t *testing.T) {
 
 func Test_nested_context(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := sql.Open("sqlite3", tmp)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -236,7 +233,7 @@ func Test_nested_context(t *testing.T) {
 
 	want(outer, 0)
 
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx, cancel := context.WithCancel(t.Context())
 	defer cancel()
 
 	inner, err := tx.QueryContext(ctx, `SELECT value FROM generate_series(0)`)
@@ -259,9 +256,9 @@ func Test_nested_context(t *testing.T) {
 
 func Test_Prepare(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := sql.Open("sqlite3", tmp)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -300,24 +297,21 @@ func Test_Prepare(t *testing.T) {
 
 func Test_QueryRow_named(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	db, err := sql.Open("sqlite3", tmp)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db.Close()
 
-	conn, err := db.Conn(ctx)
+	conn, err := db.Conn(t.Context())
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer conn.Close()
 
-	stmt, err := conn.PrepareContext(ctx, `SELECT ?, ?5, :AAA, @AAA, $AAA`)
+	stmt, err := conn.PrepareContext(t.Context(), `SELECT ?, ?5, :AAA, @AAA, $AAA`)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -353,9 +347,9 @@ func Test_QueryRow_named(t *testing.T) {
 
 func Test_QueryRow_blob_null(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := sql.Open("sqlite3", tmp)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -390,11 +384,11 @@ func Test_time(t *testing.T) {
 
 	for _, fmt := range []string{"auto", "sqlite", "rfc3339", time.ANSIC} {
 		t.Run(fmt, func(t *testing.T) {
-			tmp := memdb.TestDB(t, url.Values{
+			dsn := memdb.TestDB(t, url.Values{
 				"_timefmt": {fmt},
 			})
 
-			db, err := sql.Open("sqlite3", tmp)
+			db, err := Open(dsn)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -437,9 +431,9 @@ func Test_ColumnType_ScanType(t *testing.T) {
 	)
 
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := sql.Open("sqlite3", tmp)
+	db, err := Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -539,12 +533,8 @@ func Benchmark_loop(b *testing.B) {
 		b.Fatal(err)
 	}
 
-	ctx, cancel := context.WithCancel(context.Background())
-	b.Cleanup(cancel)
-
-	b.ResetTimer()
-	for range b.N {
-		_, err := db.ExecContext(ctx,
+	for b.Loop() {
+		_, err := db.ExecContext(b.Context(),
 			`WITH RECURSIVE c(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM c WHERE x < 1000000) SELECT x FROM c;`)
 		if err != nil {
 			b.Fatal(err)

driver/util_test.go

@@ -1,7 +1,6 @@
 package driver
 
 import (
-	"context"
 	"database/sql/driver"
 	"slices"
 	"testing"
@@ -56,7 +55,7 @@ func Fuzz_notWhitespace(f *testing.F) {
 			t.SkipNow()
 		}
 
-		c, err := db.Conn(context.Background())
+		c, err := db.Conn(t.Context())
 		if err != nil {
 			t.Fatal(err)
 		}

embed/README.md

@@ -1,6 +1,6 @@
 # Embeddable Wasm build of SQLite
 
-This folder includes an embeddable Wasm build of SQLite 3.50.3 for use with
+This folder includes an embeddable Wasm build of SQLite 3.51.1 for use with
 [`github.com/ncruces/go-sqlite3`](https://pkg.go.dev/github.com/ncruces/go-sqlite3).
 
 The following optional features are compiled in:

embed/bcw2/bcw2_test.go

@@ -53,7 +53,7 @@ func Test_bcw2(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if version != "3.51.0" {
+	if version != "3.52.0" {
 		t.Error(version)
 	}
 }

embed/bcw2/build.sh

@@ -7,20 +7,23 @@ ROOT=../../
 BINARYEN="$ROOT/tools/binaryen/bin"
 WASI_SDK="$ROOT/tools/wasi-sdk/bin"
 
-trap 'rm -rf build/ sqlite/ bcw2.tmp' EXIT
+trap 'rm -rf sqlite/ build/ bcw2.tmp' EXIT
 
+mkdir -p sqlite/
 mkdir -p build/ext/
 cp "$ROOT"/sqlite3/*.[ch] build/
 cp "$ROOT"/sqlite3/*.patch build/
+cd sqlite/
 
-# https://sqlite.org/src/info/ba2174bdca7d1d1a
-curl -# https://sqlite.org/src/tarball/sqlite.tar.gz?r=ba2174bdca | tar xz
+# https://sqlite.org/src/info/f273f6b8245c5dca
+curl -#L https://github.com/sqlite/sqlite/archive/7c126d7.tar.gz | tar xz --strip-components=1
+# curl -#L https://sqlite.org/src/tarball/sqlite.tar.gz?r=f273f6b824 | tar xz --strip-components=1
 
-cd sqlite
 if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" ]]; then
 	MSYS_NO_PATHCONV=1 nmake /f makefile.msc sqlite3.c "OPTS=-DSQLITE_ENABLE_UPDATE_DELETE_LIMIT -DSQLITE_ENABLE_ORDERED_SET_AGGREGATES"
 else
 	sh configure --enable-update-limit
+	make verify-source
 	OPTS=-DSQLITE_ENABLE_ORDERED_SET_AGGREGATES make sqlite3.c
 fi
 cd ~-
@@ -49,18 +52,22 @@ cd ~-
 	-mmutable-globals -mnontrapping-fptoint \
 	-msimd128 -mbulk-memory -msign-ext \
 	-mreference-types -mmultivalue \
-	-fno-stack-protector -fno-stack-clash-protection \
+	-mno-extended-const \
+	-fno-stack-protector \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
 	-Wl,--initial-memory=327680 \
 	-D_HAVE_SQLITE_CONFIG_H \
 	-DSQLITE_ENABLE_UPDATE_DELETE_LIMIT \
+	-DSQLITE_ENABLE_ORDERED_SET_AGGREGATES \
+	-DSQLITE_EXPERIMENTAL_PRAGMA_20251114 \
 	-DSQLITE_CUSTOM_INCLUDE=sqlite_opt.h \
 	$(awk '{print "-Wl,--export="$0}' ../exports.txt)
 
 "$BINARYEN/wasm-ctor-eval" -g -c _initialize bcw2.wasm -o bcw2.tmp
-"$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
-	bcw2.tmp -o bcw2.wasm --low-memory-unused \
+"$BINARYEN/wasm-opt" -g bcw2.tmp -o bcw2.wasm \
+	--gufa --generate-global-effects --low-memory-unused --converge -O3 \
 	--enable-mutable-globals --enable-nontrapping-float-to-int \
 	--enable-simd --enable-bulk-memory --enable-sign-ext \
-	--enable-reference-types --enable-multivalue
+	--enable-reference-types --enable-multivalue \
+	--strip --strip-producers

embed/bcw2/go.mod

@@ -1,14 +1,12 @@
 module github.com/ncruces/go-sqlite3/embed/bcw2
 
-go 1.23.0
+go 1.24.0
 
-toolchain go1.24.0
-
-require github.com/ncruces/go-sqlite3 v0.26.3
+require github.com/ncruces/go-sqlite3 v0.30.3
 
 require (
 	github.com/ncruces/julianday v1.0.0 // indirect
-	github.com/ncruces/sort v0.1.5 // indirect
-	github.com/tetratelabs/wazero v1.9.0 // indirect
-	golang.org/x/sys v0.34.0 // indirect
+	github.com/ncruces/sort v0.1.6 // indirect
+	github.com/tetratelabs/wazero v1.11.0 // indirect
+	golang.org/x/sys v0.39.0 // indirect
 )

embed/bcw2/go.sum

@@ -1,12 +1,12 @@
-github.com/ncruces/go-sqlite3 v0.26.3 h1:WFkQj4KNMhbqiBPGDrVpK74w1DzcxQu3wYpmdWAvfYM=
-github.com/ncruces/go-sqlite3 v0.26.3/go.mod h1:XFTPtFIo1DmGCh+XVP8KGn9b/o2f+z0WZuT09x2N6eo=
+github.com/ncruces/go-sqlite3 v0.30.3 h1:X/CgWW9GzmIAkEPrifhKqf0cC15DuOVxAJaHFTTAURQ=
+github.com/ncruces/go-sqlite3 v0.30.3/go.mod h1:AxKu9sRxkludimFocbktlY6LiYSkxiI5gTA8r+os/Nw=
 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.5 h1:fiFWXXAqKI8QckPf/6hu/bGFwcEPrirIOFaJqWujs4k=
-github.com/ncruces/sort v0.1.5/go.mod h1:obJToO4rYr6VWP0Uw5FYymgYGt3Br4RXcs/JdKaXAPk=
-github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
-github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
-golang.org/x/sys v0.34.0 h1:H5Y5sJ2L2JRdyv7ROF1he/lPdvFsd0mJHFw2ThKHxLA=
-golang.org/x/sys v0.34.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=
-golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
+github.com/ncruces/sort v0.1.6 h1:TrsJfGRH1AoWoaeB4/+gCohot9+cA6u/INaH5agIhNk=
+github.com/ncruces/sort v0.1.6/go.mod h1:obJToO4rYr6VWP0Uw5FYymgYGt3Br4RXcs/JdKaXAPk=
+github.com/tetratelabs/wazero v1.11.0 h1:+gKemEuKCTevU4d7ZTzlsvgd1uaToIDtlQlmNbwqYhA=
+github.com/tetratelabs/wazero v1.11.0/go.mod h1:eV28rsN8Q+xwjogd7f4/Pp4xFxO7uOGbLcD/LzB1wiU=
+golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk=
+golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
+golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=

embed/build.sh

@@ -17,17 +17,20 @@ trap 'rm -f sqlite3.tmp' EXIT
 	-mmutable-globals -mnontrapping-fptoint \
 	-msimd128 -mbulk-memory -msign-ext \
 	-mreference-types -mmultivalue \
-	-fno-stack-protector -fno-stack-clash-protection \
+	-mno-extended-const \
+	-fno-stack-protector \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
 	-Wl,--initial-memory=327680 \
 	-D_HAVE_SQLITE_CONFIG_H \
+	-DSQLITE_EXPERIMENTAL_PRAGMA_20251114 \
 	-DSQLITE_CUSTOM_INCLUDE=sqlite_opt.h \
 	$(awk '{print "-Wl,--export="$0}' exports.txt)
 
 "$BINARYEN/wasm-ctor-eval" -g -c _initialize sqlite3.wasm -o sqlite3.tmp
-"$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
-	sqlite3.tmp -o sqlite3.wasm --low-memory-unused \
+"$BINARYEN/wasm-opt" -g sqlite3.tmp -o sqlite3.wasm \
+	--gufa --generate-global-effects --low-memory-unused --converge -O3 \
 	--enable-mutable-globals --enable-nontrapping-float-to-int \
 	--enable-simd --enable-bulk-memory --enable-sign-ext \
-	--enable-reference-types --enable-multivalue
+	--enable-reference-types --enable-multivalue \
+	--strip --strip-producers

embed/exports.txt

@@ -59,7 +59,7 @@ sqlite3_db_filename
 sqlite3_db_name
 sqlite3_db_readonly
 sqlite3_db_release_memory
-sqlite3_db_status
+sqlite3_db_status64
 sqlite3_declare_vtab
 sqlite3_errcode
 sqlite3_errmsg

embed/init.go

@@ -17,5 +17,7 @@ import (
 var binary string
 
 func init() {
-	sqlite3.Binary = unsafe.Slice(unsafe.StringData(binary), len(binary))
+	if sqlite3.Binary == nil {
+		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.50.3" {
+	if version != "3.51.1" {
 		t.Error(version)
 	}
 }

error.go

@@ -11,6 +11,7 @@ import (
 //
 // https://sqlite.org/c3ref/errcode.html
 type Error struct {
+	sys  error
 	msg  string
 	sql  string
 	code res_t
@@ -33,16 +34,28 @@ func (e *Error) ExtendedCode() ExtendedErrorCode {
 // Error implements the error interface.
 func (e *Error) Error() string {
 	var b strings.Builder
-	b.WriteString(util.ErrorCodeString(uint32(e.code)))
+	b.WriteString(util.ErrorCodeString(e.code))
 
 	if e.msg != "" {
 		b.WriteString(": ")
 		b.WriteString(e.msg)
 	}
+	if e.sys != nil {
+		b.WriteString(": ")
+		b.WriteString(e.sys.Error())
+	}
 
 	return b.String()
 }
 
+// Unwrap returns the underlying operating system error
+// that caused the I/O error or failure to open a file.
+//
+// https://sqlite.org/c3ref/system_errno.html
+func (e *Error) Unwrap() error {
+	return e.sys
+}
+
 // Is tests whether this error matches a given [ErrorCode] or [ExtendedErrorCode].
 //
 // It makes it possible to do:
@@ -90,7 +103,16 @@ func (e *Error) SQL() string {
 
 // Error implements the error interface.
 func (e ErrorCode) Error() string {
-	return util.ErrorCodeString(uint32(e))
+	return util.ErrorCodeString(e)
+}
+
+// As converts this error to an [ExtendedErrorCode].
+func (e ErrorCode) As(err any) bool {
+	c, ok := err.(*xErrorCode)
+	if ok {
+		*c = xErrorCode(e)
+	}
+	return ok
 }
 
 // Temporary returns true for [BUSY] errors.
@@ -105,7 +127,7 @@ func (e ErrorCode) ExtendedCode() ExtendedErrorCode {
 
 // Error implements the error interface.
 func (e ExtendedErrorCode) Error() string {
-	return util.ErrorCodeString(uint32(e))
+	return util.ErrorCodeString(e)
 }
 
 // Is tests whether this error matches a given [ErrorCode].
@@ -150,14 +172,10 @@ func errorCode(err error, def ErrorCode) (msg string, code res_t) {
 		return code.msg, res_t(code.code)
 	}
 
-	var ecode ErrorCode
 	var xcode xErrorCode
-	switch {
-	case errors.As(err, &xcode):
+	if errors.As(err, &xcode) {
 		code = res_t(xcode)
-	case errors.As(err, &ecode):
-		code = res_t(ecode)
-	default:
+	} else {
 		code = res_t(def)
 	}
 	return err.Error(), code

ext/README.md

@@ -38,11 +38,11 @@ you can load into your database connections.
 - [`github.com/ncruces/go-sqlite3/ext/zorder`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/zorder)
   maps multidimensional data to one dimension.
 
-### Pakages
+### Packages
 
 These packages may also be useful to work with SQLite:
 
 - [`github.com/ncruces/decimal`](https://pkg.go.dev/github.com/ncruces/decimal)
   decimal arithmetic.
 - [`github.com/ncruces/julianday`](https://pkg.go.dev/github.com/ncruces/julianday)
-  Julian day math.
+  Julian day math.

ext/array/array.go

@@ -59,7 +59,8 @@ func (c *cursor) Next() error {
 }
 
 func (c *cursor) RowID() (int64, error) {
-	return int64(c.rowID), nil
+	// One-based RowID for consistency with carray and other tables.
+	return int64(c.rowID) + 1, nil
 }
 
 func (c *cursor) Column(ctx sqlite3.Context, n int) error {

ext/array/array_test.go

@@ -88,9 +88,9 @@ func Example() {
 
 func Test_cursor_Column(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, array.Register)
+	db, err := driver.Open(dsn, array.Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/bloom/bloom.go

@@ -16,6 +16,7 @@ import (
 
 	"github.com/ncruces/go-sqlite3"
 	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/ncruces/go-sqlite3/util/sql3util"
 )
 
 // Register registers the bloom_filter virtual table:
@@ -34,6 +35,8 @@ type bloom struct {
 	hashes  int
 }
 
+const vtab = `CREATE TABLE x(present, word TEXT HIDDEN NOT NULL PRIMARY KEY) WITHOUT ROWID`
+
 func create(db *sqlite3.Conn, _, schema, table string, arg ...string) (_ *bloom, err error) {
 	b := bloom{
 		db:      db,
@@ -55,11 +58,9 @@ func create(db *sqlite3.Conn, _, schema, table string, arg ...string) (_ *bloom,
 	}
 
 	if len(arg) > 1 {
-		b.prob, err = strconv.ParseFloat(arg[1], 64)
-		if err != nil {
-			return nil, err
-		}
-		if b.prob <= 0 || b.prob >= 1 {
+		var ok bool
+		b.prob, ok = sql3util.ParseFloat(arg[1])
+		if !ok || b.prob <= 0 || b.prob >= 1 {
 			return nil, util.ErrorString("bloom: probability must be in the range (0,1)")
 		}
 	} else {
@@ -80,8 +81,7 @@ func create(db *sqlite3.Conn, _, schema, table string, arg ...string) (_ *bloom,
 
 	b.bytes = numBytes(nelem, b.prob)
 
-	err = db.DeclareVTab(
-		`CREATE TABLE x(present, word HIDDEN NOT NULL PRIMARY KEY) WITHOUT ROWID`)
+	err = db.DeclareVTab(vtab)
 	if err != nil {
 		return nil, err
 	}
@@ -115,15 +115,15 @@ func connect(db *sqlite3.Conn, _, schema, table string, arg ...string) (_ *bloom
 		storage: table + "_storage",
 	}
 
-	err = db.DeclareVTab(
-		`CREATE TABLE x(present, word HIDDEN NOT NULL PRIMARY KEY) WITHOUT ROWID`)
+	err = db.DeclareVTab(vtab)
 	if err != nil {
 		return nil, err
 	}
 
-	load, _, err := db.Prepare(fmt.Sprintf(
+	load, _, err := db.PrepareFlags(fmt.Sprintf(
 		`SELECT m/8, p, k FROM %s.%s WHERE rowid = 1`,
-		sqlite3.QuoteIdentifier(b.schema), sqlite3.QuoteIdentifier(b.storage)))
+		sqlite3.QuoteIdentifier(b.schema), sqlite3.QuoteIdentifier(b.storage)),
+		sqlite3.PREPARE_DONT_LOG)
 	if err != nil {
 		return nil, err
 	}
@@ -166,9 +166,10 @@ func (t *bloom) ShadowTables() {
 }
 
 func (t *bloom) Integrity(schema, table string, flags int) error {
-	load, _, err := t.db.Prepare(fmt.Sprintf(
+	load, _, err := t.db.PrepareFlags(fmt.Sprintf(
 		`SELECT typeof(data), length(data), p, n, m, k FROM %s.%s WHERE rowid = 1`,
-		sqlite3.QuoteIdentifier(t.schema), sqlite3.QuoteIdentifier(t.storage)))
+		sqlite3.QuoteIdentifier(t.schema), sqlite3.QuoteIdentifier(t.storage)),
+		sqlite3.PREPARE_DONT_LOG)
 	if err != nil {
 		return fmt.Errorf("bloom: %v", err) // can't wrap!
 	}

ext/closure/closure.go

@@ -56,7 +56,7 @@ func Register(db *sqlite3.Conn) error {
 				done.Add(key)
 			}
 
-			err := db.DeclareVTab(`CREATE TABLE x(id,depth,root HIDDEN,tablename HIDDEN,idcolumn HIDDEN,parentcolumn HIDDEN)`)
+			err := db.DeclareVTab(`CREATE TABLE x(id INT,depth INT,root HIDDEN,tablename TEXT HIDDEN,idcolumn TEXT HIDDEN,parentcolumn TEXT HIDDEN)`)
 			if err != nil {
 				return nil, err
 			}
@@ -154,6 +154,7 @@ func (c *closure) BestIndex(idx *sqlite3.IndexInfo) error {
 		return sqlite3.CONSTRAINT
 	}
 
+	idx.IdxFlags = sqlite3.INDEX_SCAN_HEX
 	idx.EstimatedCost = cost
 	idx.IdxNum = plan
 	return nil
@@ -201,7 +202,7 @@ func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
 		sqlite3.QuoteIdentifier(column),
 		sqlite3.QuoteIdentifier(parent),
 	)
-	stmt, _, err := c.db.Prepare(sql)
+	stmt, _, err := c.db.PrepareFlags(sql, sqlite3.PREPARE_DONT_LOG)
 	if err != nil {
 		return err
 	}

ext/csv/csv.go

@@ -100,7 +100,7 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
 			}
 			schema = getSchema(header, columns, row)
 		} else {
-			t.typs, err = getColumnAffinities(schema)
+			t.typs, err = getColumnAffinities(db, schema)
 			if err != nil {
 				return nil, err
 			}
@@ -254,19 +254,15 @@ func (c *cursor) Column(ctx sqlite3.Context, col int) error {
 
 		switch typ {
 		case numeric, integer:
-			if strings.TrimLeft(txt, "+-0123456789") == "" {
-				if i, err := strconv.ParseInt(txt, 10, 64); err == nil {
-					ctx.ResultInt64(i)
-					return nil
-				}
+			if i, err := strconv.ParseInt(txt, 10, 64); err == nil {
+				ctx.ResultInt64(i)
+				return nil
 			}
 			fallthrough
 		case real:
-			if strings.TrimLeft(txt, "+-.0123456789Ee") == "" {
-				if f, err := strconv.ParseFloat(txt, 64); err == nil {
-					ctx.ResultFloat(f)
-					return nil
-				}
+			if f, ok := sql3util.ParseFloat(txt); ok {
+				ctx.ResultFloat(f)
+				return nil
 			}
 			fallthrough
 		default:

ext/csv/types.go

@@ -3,6 +3,8 @@ package csv
 import (
 	"strings"
 
+	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/internal/util"
 	"github.com/ncruces/go-sqlite3/util/sql3util"
 )
 
@@ -16,7 +18,17 @@ const (
 	real    affinity = 4
 )
 
-func getColumnAffinities(schema string) ([]affinity, error) {
+func getColumnAffinities(db *sqlite3.Conn, schema string) ([]affinity, error) {
+	stmt, tail, err := db.PrepareFlags(schema,
+		sqlite3.PREPARE_DONT_LOG|sqlite3.PREPARE_NO_VTAB|sqlite3.PREPARE_FROM_DDL)
+	if err != nil {
+		return nil, err
+	}
+	stmt.Close()
+	if tail != "" {
+		return nil, util.TailErr
+	}
+
 	tab, err := sql3util.ParseTable(schema)
 	if err != nil {
 		return nil, err

ext/fileio/fileio.go

@@ -18,7 +18,7 @@ func Register(db *sqlite3.Conn) error {
 	return RegisterFS(db, nil)
 }
 
-// Register registers SQL functions readfile, lsmode,
+// RegisterFS registers SQL functions readfile, lsmode,
 // and the table-valued function fsdir;
 // fsys will be used to read files and list directories.
 func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
@@ -30,7 +30,7 @@ func RegisterFS(db *sqlite3.Conn, fsys fs.FS) error {
 		db.CreateFunction("readfile", 1, sqlite3.DIRECTONLY, readfile(fsys)),
 		db.CreateFunction("lsmode", 1, sqlite3.DETERMINISTIC, lsmode),
 		sqlite3.CreateModule(db, "fsdir", nil, func(db *sqlite3.Conn, _, _, _ string, _ ...string) (fsdir, error) {
-			err := db.DeclareVTab(`CREATE TABLE x(name,mode,mtime TIMESTAMP,data,path HIDDEN,dir HIDDEN)`)
+			err := db.DeclareVTab(`CREATE TABLE x(name TEXT,mode INT,mtime TIMESTAMP,data BLOB,path HIDDEN,dir HIDDEN)`)
 			if err == nil {
 				err = db.VTabConfig(sqlite3.VTAB_DIRECTONLY)
 			}

ext/fileio/fileio_test.go

@@ -17,9 +17,9 @@ import (
 
 func Test_lsmode(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, fileio.Register)
+	db, err := driver.Open(dsn, fileio.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -53,9 +53,9 @@ func Test_readfile(t *testing.T) {
 
 	for _, fsys := range []fs.FS{nil, os.DirFS(".")} {
 		t.Run("", func(t *testing.T) {
-			tmp := memdb.TestDB(t)
+			dsn := memdb.TestDB(t)
 
-			db, err := driver.Open(tmp, func(c *sqlite3.Conn) error {
+			db, err := driver.Open(dsn, func(c *sqlite3.Conn) error {
 				fileio.RegisterFS(c, fsys)
 				return nil
 			})

ext/fileio/fsdir_test.go

@@ -21,9 +21,9 @@ func Test_fsdir(t *testing.T) {
 
 	for _, fsys := range []fs.FS{nil, os.DirFS(".")} {
 		t.Run("", func(t *testing.T) {
-			tmp := memdb.TestDB(t)
+			dsn := memdb.TestDB(t)
 
-			db, err := driver.Open(tmp, func(c *sqlite3.Conn) error {
+			db, err := driver.Open(dsn, func(c *sqlite3.Conn) error {
 				fileio.RegisterFS(c, fsys)
 				return nil
 			})

ext/fileio/write_test.go

@@ -15,9 +15,9 @@ import (
 
 func Test_writefile(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, Register)
+	db, err := driver.Open(dsn, Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/hash/hash_test.go

@@ -4,6 +4,7 @@ import (
 	_ "crypto/md5"
 	_ "crypto/sha1"
 	_ "crypto/sha256"
+	_ "crypto/sha3"
 	_ "crypto/sha512"
 	"testing"
 
@@ -11,7 +12,6 @@ import (
 	_ "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"
@@ -21,7 +21,7 @@ import (
 
 func TestRegister(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
 	tests := []struct {
 		name string
@@ -55,7 +55,7 @@ func TestRegister(t *testing.T) {
 		{"blake2b('', 256)", "0E5751C026E543B2E8AB2EB06099DAA1D1E5DF47778F7787FAAB45CDF12FE3A8"},
 	}
 
-	db, err := driver.Open(tmp, Register)
+	db, err := driver.Open(dsn, Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/ipaddr/ipaddr_test.go

@@ -12,9 +12,9 @@ import (
 
 func TestRegister(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, ipaddr.Register)
+	db, err := driver.Open(dsn, ipaddr.Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/lines/lines_test.go

@@ -67,9 +67,9 @@ func Example() {
 
 func Test_lines(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, lines.Register)
+	db, err := driver.Open(dsn, lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -98,9 +98,9 @@ func Test_lines(t *testing.T) {
 
 func Test_lines_error(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, lines.Register)
+	db, err := driver.Open(dsn, lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -123,9 +123,9 @@ func Test_lines_error(t *testing.T) {
 
 func Test_lines_read(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, lines.Register)
+	db, err := driver.Open(dsn, lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -155,9 +155,9 @@ func Test_lines_read(t *testing.T) {
 
 func Test_lines_test(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, lines.Register)
+	db, err := driver.Open(dsn, lines.Register)
 	if err != nil {
 		log.Fatal(err)
 	}

ext/pivot/pivot.go

@@ -43,11 +43,14 @@ func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (ret *table, err e
 
 	// Row key query.
 	t.scan = "SELECT * FROM\n" + arg[0]
-	stmt, _, err := db.Prepare(t.scan)
+	stmt, tail, err := db.PrepareFlags(t.scan, sqlite3.PREPARE_FROM_DDL)
 	if err != nil {
 		return nil, err
 	}
 	defer stmt.Close()
+	if tail != "" {
+		return nil, util.TailErr
+	}
 
 	t.keys = make([]string, stmt.ColumnCount())
 	for i := range t.keys {
@@ -55,15 +58,20 @@ func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (ret *table, err e
 		t.keys[i] = name
 		create.WriteString(sep)
 		create.WriteString(name)
+		create.WriteString(" ")
+		create.WriteString(stmt.ColumnDeclType(i))
 		sep = ","
 	}
 	stmt.Close()
 
 	// Column definition query.
-	stmt, _, err = db.Prepare("SELECT * FROM\n" + arg[1])
+	stmt, tail, err = db.PrepareFlags("SELECT * FROM\n"+arg[1], sqlite3.PREPARE_FROM_DDL)
 	if err != nil {
 		return nil, err
 	}
+	if tail != "" {
+		return nil, util.TailErr
+	}
 
 	if stmt.ColumnCount() != 2 {
 		return nil, util.ErrorString("pivot: column definition query expects 2 result columns")
@@ -71,17 +79,23 @@ func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (ret *table, err e
 	for stmt.Step() {
 		name := sqlite3.QuoteIdentifier(stmt.ColumnText(1))
 		t.cols = append(t.cols, stmt.ColumnValue(0).Dup())
-		create.WriteString(",")
+		create.WriteString(sep)
 		create.WriteString(name)
+		create.WriteString(" ")
+		create.WriteString(stmt.ColumnDeclType(1))
+		sep = ","
 	}
 	stmt.Close()
 
 	// Pivot cell query.
 	t.cell = "SELECT * FROM\n" + arg[2]
-	stmt, _, err = db.Prepare(t.cell)
+	stmt, tail, err = db.PrepareFlags(t.cell, sqlite3.PREPARE_FROM_DDL)
 	if err != nil {
 		return nil, err
 	}
+	if tail != "" {
+		return nil, util.TailErr
+	}
 
 	if stmt.ColumnCount() != 1 {
 		return nil, util.ErrorString("pivot: cell query expects 1 result columns")
@@ -182,7 +196,9 @@ func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
 		return err
 	}
 
-	c.scan, _, err = c.table.db.Prepare(idxStr)
+	const prepflags = sqlite3.PREPARE_DONT_LOG | sqlite3.PREPARE_FROM_DDL
+
+	c.scan, _, err = c.table.db.PrepareFlags(idxStr, prepflags)
 	if err != nil {
 		return err
 	}
@@ -194,7 +210,7 @@ func (c *cursor) Filter(idxNum int, idxStr string, arg ...sqlite3.Value) error {
 	}
 
 	if c.cell == nil {
-		c.cell, _, err = c.table.db.Prepare(c.table.cell)
+		c.cell, _, err = c.table.db.PrepareFlags(c.table.cell, prepflags)
 		if err != nil {
 			return err
 		}

ext/regexp/regexp_test.go

@@ -15,9 +15,9 @@ import (
 
 func TestRegister(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, Register)
+	db, err := driver.Open(dsn, Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -80,9 +80,9 @@ func TestRegister(t *testing.T) {
 
 func TestRegister_errors(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, Register)
+	db, err := driver.Open(dsn, Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -107,9 +107,9 @@ func TestRegister_errors(t *testing.T) {
 
 func TestRegister_pointer(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, Register)
+	db, err := driver.Open(dsn, Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/serdes/serdes.go

@@ -2,9 +2,8 @@
 package serdes
 
 import (
-	"io"
-
 	"github.com/ncruces/go-sqlite3"
+	"github.com/ncruces/go-sqlite3/util/vfsutil"
 	"github.com/ncruces/go-sqlite3/vfs"
 )
 
@@ -14,16 +13,16 @@ func init() {
 	vfs.Register(vfsName, sliceVFS{})
 }
 
-var fileToOpen = make(chan *sliceFile, 1)
+var fileToOpen = make(chan *[]byte, 1)
 
 // Serialize backs up a database into a byte slice.
 //
 // https://sqlite.org/c3ref/serialize.html
 func Serialize(db *sqlite3.Conn, schema string) ([]byte, error) {
-	var file sliceFile
+	var file []byte
 	fileToOpen <- &file
-	err := db.Backup(schema, "file:serdes.db?vfs="+vfsName)
-	return file.data, err
+	err := db.Backup(schema, "file:serdes.db?nolock=1&vfs="+vfsName)
+	return file, err
 }
 
 // Deserialize restores a database from a byte slice,
@@ -41,8 +40,8 @@ func Serialize(db *sqlite3.Conn, schema string) ([]byte, error) {
 // ["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:serdes.db?vfs="+vfsName)
+	fileToOpen <- &data
+	return db.Restore(schema, "file:serdes.db?immutable=1&vfs="+vfsName)
 }
 
 type sliceVFS struct{}
@@ -53,14 +52,14 @@ func (sliceVFS) Open(name string, flags vfs.OpenFlag) (vfs.File, vfs.OpenFlag, e
 	}
 	select {
 	case file := <-fileToOpen:
-		return file, flags | vfs.OPEN_MEMORY, nil
+		return (*vfsutil.SliceFile)(file), flags | vfs.OPEN_MEMORY, nil
 	default:
 		return nil, flags, sqlite3.MISUSE
 	}
 }
 
 func (sliceVFS) Delete(name string, dirSync bool) error {
-	// notest // OPEN_MEMORY
+	// notest // no journals to delete
 	return sqlite3.IOERR_DELETE
 }
 
@@ -71,70 +70,3 @@ func (sliceVFS) Access(name string, flag vfs.AccessFlag) (bool, error) {
 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

@@ -1,6 +1,7 @@
 package serdes_test
 
 import (
+	_ "embed"
 	"errors"
 	"io"
 	"net/http"
@@ -11,7 +12,30 @@ import (
 	"github.com/ncruces/go-sqlite3/ext/serdes"
 )
 
-func TestDeserialize(t *testing.T) {
+//go:embed testdata/wal.db
+var walDB []byte
+
+func Test_wal(t *testing.T) {
+	db, err := sqlite3.Open("testdata/wal.db")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	data, err := serdes.Serialize(db, "main")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	compareDBs(t, data, walDB)
+
+	err = serdes.Deserialize(db, "temp", walDB)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func Test_northwind(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping in short mode")
 	}
@@ -37,10 +61,14 @@ func TestDeserialize(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if len(input) != len(output) {
+	compareDBs(t, input, output)
+}
+
+func compareDBs(t *testing.T, a, b []byte) {
+	if len(a) != len(b) {
 		t.Fatal("lengths are different")
 	}
-	for i := range input {
+	for i := range a {
 		// These may be different.
 		switch {
 		case 24 <= i && i < 28:
@@ -53,14 +81,14 @@ func TestDeserialize(t *testing.T) {
 			// SQLite version that wrote the file.
 			continue
 		}
-		if input[i] != output[i] {
-			t.Errorf("difference at %d: %d %d", i, input[i], output[i])
+		if a[i] != b[i] {
+			t.Errorf("difference at %d: %d %d", i, a[i], b[i])
 		}
 	}
 }
 
 func httpGet() ([]byte, error) {
-	res, err := http.Get("https://raw.githubusercontent.com/jpwhite3/northwind-SQLite3/refs/heads/main/dist/northwind.db")
+	res, err := http.Get("https://github.com/jpwhite3/northwind-SQLite3/raw/refs/heads/main/dist/northwind.db")
 	if err != nil {
 		return nil, err
 	}

ext/statement/stmt.go

@@ -35,10 +35,15 @@ func declare(db *sqlite3.Conn, _, _, _ string, arg ...string) (*table, error) {
 
 	sql := "SELECT * FROM\n" + arg[0]
 
-	stmt, _, err := db.PrepareFlags(sql, sqlite3.PREPARE_PERSISTENT)
+	stmt, tail, err := db.PrepareFlags(sql,
+		sqlite3.PREPARE_PERSISTENT|sqlite3.PREPARE_FROM_DDL)
 	if err != nil {
 		return nil, err
 	}
+	if tail != "" {
+		stmt.Close()
+		return nil, util.TailErr
+	}
 
 	var sep string
 	var str strings.Builder
@@ -129,7 +134,8 @@ func (t *table) Open() (_ sqlite3.VTabCursor, err error) {
 	if !t.inuse {
 		t.inuse = true
 	} else {
-		stmt, _, err = t.stmt.Conn().Prepare(t.sql)
+		stmt, _, err = t.stmt.Conn().PrepareFlags(t.sql,
+			sqlite3.PREPARE_DONT_LOG|sqlite3.PREPARE_FROM_DDL)
 		if err != nil {
 			return nil, err
 		}

ext/unicode/unicode.go

@@ -43,7 +43,7 @@ import (
 	"github.com/ncruces/go-sqlite3/internal/util"
 )
 
-// Set RegisterLike to false to not register a Unicode aware LIKE operator.
+// RegisterLike must be set to false to not register a Unicode aware LIKE operator.
 // Overriding the built-in LIKE operator disables the [LIKE optimization].
 //
 // [LIKE optimization]: https://sqlite.org/optoverview.html#the_like_optimization

ext/uuid/uuid.go

@@ -194,7 +194,7 @@ func timestamp(ctx sqlite3.Context, arg ...sqlite3.Value) {
 		switch u.Version() {
 		case 1, 2, 6, 7:
 			ctx.ResultTime(
-				time.Unix(u.Time().UnixTime()),
+				time.Unix(u.Time().UnixTime()).UTC(),
 				sqlite3.TimeFormatDefault)
 		}
 	}

ext/uuid/uuid_test.go

@@ -14,9 +14,9 @@ import (
 
 func Test_generate(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, Register)
+	db, err := driver.Open(dsn, Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -153,9 +153,9 @@ func Test_generate(t *testing.T) {
 
 func Test_convert(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, Register)
+	db, err := driver.Open(dsn, Register)
 	if err != nil {
 		t.Fatal(err)
 	}

ext/zorder/zorder.go

@@ -19,9 +19,9 @@ func Register(db *sqlite3.Conn) error {
 }
 
 func zorder(ctx sqlite3.Context, arg ...sqlite3.Value) {
-	var x [63]int64
-	if len(arg) > len(x) {
-		ctx.ResultError(util.ErrorString("zorder: too many parameters"))
+	var x [24]int64
+	if n := len(arg); n < 2 || n > 24 {
+		ctx.ResultError(util.ErrorString("zorder: needs between 2 and 24 dimensions"))
 		return
 	}
 	for i := range arg {
@@ -29,17 +29,15 @@ func zorder(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	}
 
 	var z int64
-	if len(arg) > 0 {
-		for i := range x {
-			j := i % len(arg)
-			z |= (x[j] & 1) << i
-			x[j] >>= 1
-		}
+	for i := range 63 {
+		j := i % len(arg)
+		z |= (x[j] & 1) << i
+		x[j] >>= 1
 	}
 
 	for i := range arg {
 		if x[i] != 0 {
-			ctx.ResultError(util.ErrorString("zorder: parameter too large"))
+			ctx.ResultError(util.ErrorString("zorder: argument out of range"))
 			return
 		}
 	}
@@ -51,6 +49,19 @@ func unzorder(ctx sqlite3.Context, arg ...sqlite3.Value) {
 	n := arg[1].Int64()
 	z := arg[0].Int64()
 
+	if n < 2 || n > 24 {
+		ctx.ResultError(util.ErrorString("unzorder: needs between 2 and 24 dimensions"))
+		return
+	}
+	if i < 0 || i >= n {
+		ctx.ResultError(util.ErrorString("unzorder: index out of range"))
+		return
+	}
+	if z < 0 {
+		ctx.ResultError(util.ErrorString("unzorder: argument out of range"))
+		return
+	}
+
 	var k int
 	var x int64
 	for j := i; j < 63; j += n {

ext/zorder/zorder_test.go

@@ -12,11 +12,11 @@ import (
 	"github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
-func TestRegister_zorder(t *testing.T) {
+func Test_zorder(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, zorder.Register)
+	db, err := driver.Open(dsn, zorder.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -57,11 +57,11 @@ func TestRegister_zorder(t *testing.T) {
 	}
 }
 
-func TestRegister_unzorder(t *testing.T) {
+func Test_unzorder(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, zorder.Register)
+	db, err := driver.Open(dsn, zorder.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -85,11 +85,11 @@ func TestRegister_unzorder(t *testing.T) {
 	}
 }
 
-func TestRegister_error(t *testing.T) {
+func Test_zorder_error(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db, err := driver.Open(tmp, zorder.Register)
+	db, err := driver.Open(dsn, zorder.Register)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -103,7 +103,7 @@ func TestRegister_error(t *testing.T) {
 
 	var buf strings.Builder
 	buf.WriteString("SELECT zorder(0")
-	for i := 1; i < 80; i++ {
+	for i := 1; i < 25; i++ {
 		buf.WriteByte(',')
 		buf.WriteString(strconv.Itoa(0))
 	}
@@ -113,3 +113,30 @@ func TestRegister_error(t *testing.T) {
 		t.Error("want error")
 	}
 }
+
+func Test_unzorder_error(t *testing.T) {
+	t.Parallel()
+	dsn := memdb.TestDB(t)
+
+	db, err := driver.Open(dsn, zorder.Register)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	var got int64
+	err = db.QueryRow(`SELECT unzorder(-1, 2, 0)`).Scan(&got)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	err = db.QueryRow(`SELECT unzorder(0, 2, 2)`).Scan(&got)
+	if err == nil {
+		t.Error("want error")
+	}
+
+	err = db.QueryRow(`SELECT unzorder(0, 25, 2)`).Scan(&got)
+	if err == nil {
+		t.Error("want error")
+	}
+}

func.go

@@ -59,7 +59,7 @@ func (c *Conn) CreateCollation(name string, fn CollatingFunction) error {
 	return c.error(rc)
 }
 
-// Collating function is the type of a collation callback.
+// CollatingFunction is the type of a collation callback.
 // Implementations must not retain a or b.
 type CollatingFunction func(a, b []byte) int
 
@@ -132,7 +132,7 @@ func (c *Conn) CreateWindowFunction(name string, nArg int, flag FunctionFlag, fn
 			if win, ok := agg.(WindowFunction); ok {
 				return win
 			}
-			return windowFunc{agg, name}
+			return agg
 		}))
 	}
 	rc := res_t(c.call("sqlite3_create_window_function_go",
@@ -307,13 +307,3 @@ func (a *aggregateFunc) Close() error {
 	a.stop()
 	return nil
 }
-
-type windowFunc struct {
-	AggregateFunction
-	name string
-}
-
-func (w windowFunc) Inverse(ctx Context, arg ...Value) {
-	// Implementing inverse allows certain queries that don't really need it to succeed.
-	ctx.ResultError(util.ErrorString(w.name + ": may not be used as a window function"))
-}

go.mod

@@ -1,23 +1,22 @@
 module github.com/ncruces/go-sqlite3
 
-go 1.23.0
-
-toolchain go1.24.0
+go 1.24.0
 
 require (
 	github.com/ncruces/julianday v1.0.0
-	github.com/ncruces/sort v0.1.5
-	github.com/tetratelabs/wazero v1.9.0
-	golang.org/x/crypto v0.40.0
-	golang.org/x/sys v0.34.0
+	github.com/ncruces/sort v0.1.6
+	github.com/ncruces/wbt v1.0.0
+	github.com/tetratelabs/wazero v1.11.0
+	golang.org/x/sys v0.40.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.16.0 // test
-	golang.org/x/text v0.27.0 // ext/unicode
+	golang.org/x/crypto v0.47.0 // vfs/adiantum vfs/xts
+	golang.org/x/sync v0.19.0 // test
+	golang.org/x/text v0.33.0 // ext/unicode
 	lukechampine.com/adiantum v1.1.1 // vfs/adiantum
 )
 

go.sum

@@ -4,19 +4,21 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 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.5 h1:fiFWXXAqKI8QckPf/6hu/bGFwcEPrirIOFaJqWujs4k=
-github.com/ncruces/sort v0.1.5/go.mod h1:obJToO4rYr6VWP0Uw5FYymgYGt3Br4RXcs/JdKaXAPk=
+github.com/ncruces/sort v0.1.6 h1:TrsJfGRH1AoWoaeB4/+gCohot9+cA6u/INaH5agIhNk=
+github.com/ncruces/sort v0.1.6/go.mod h1:obJToO4rYr6VWP0Uw5FYymgYGt3Br4RXcs/JdKaXAPk=
+github.com/ncruces/wbt v1.0.0 h1:8iBE7UPjTLUpzu3/FCRjAmuQjWzgxo10RGBgt3ooLSc=
+github.com/ncruces/wbt v1.0.0/go.mod h1:DtF92amvMxH69EmBFUSFWRDAlo6hOEfoNQnClxj9C/c=
 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.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
-github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
-golang.org/x/crypto v0.40.0 h1:r4x+VvoG5Fm+eJcxMaY8CQM7Lb0l1lsmjGBQ6s8BfKM=
-golang.org/x/crypto v0.40.0/go.mod h1:Qr1vMER5WyS2dfPHAlsOj01wgLbsyWtFn/aY+5+ZdxY=
-golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
-golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
-golang.org/x/sys v0.34.0 h1:H5Y5sJ2L2JRdyv7ROF1he/lPdvFsd0mJHFw2ThKHxLA=
-golang.org/x/sys v0.34.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.27.0 h1:4fGWRpyh641NLlecmyl4LOe6yDdfaYNrGb2zdfo4JV4=
-golang.org/x/text v0.27.0/go.mod h1:1D28KMCvyooCX9hBiosv5Tz/+YLxj0j7XhWjpSUF7CU=
+github.com/tetratelabs/wazero v1.11.0 h1:+gKemEuKCTevU4d7ZTzlsvgd1uaToIDtlQlmNbwqYhA=
+github.com/tetratelabs/wazero v1.11.0/go.mod h1:eV28rsN8Q+xwjogd7f4/Pp4xFxO7uOGbLcD/LzB1wiU=
+golang.org/x/crypto v0.47.0 h1:V6e3FRj+n4dbpw86FJ8Fv7XVOql7TEwpHapKoMJ/GO8=
+golang.org/x/crypto v0.47.0/go.mod h1:ff3Y9VzzKbwSSEzWqJsJVBnWmRwRSHt/6Op5n9bQc4A=
+golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
+golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ=
+golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/text v0.33.0 h1:B3njUFyqtHDUI5jMn1YIr5B0IE2U0qck04r6d4KPAxE=
+golang.org/x/text v0.33.0/go.mod h1:LuMebE6+rBincTi9+xWTY8TztLzKHc/9C1uBCG27+q8=
 lukechampine.com/adiantum v1.1.1 h1:4fp6gTxWCqpEbLy40ExiYDDED3oUNWx5cTqBCtPdZqA=
 lukechampine.com/adiantum v1.1.1/go.mod h1:LrAYVnTYLnUtE/yMp5bQr0HstAf060YUF8nM0B6+rUw=

gormlite/go.mod

@@ -1,19 +1,17 @@
 module github.com/ncruces/go-sqlite3/gormlite
 
-go 1.23.0
-
-toolchain go1.24.0
+go 1.24.0
 
 require (
-	github.com/ncruces/go-sqlite3 v0.26.3
-	gorm.io/gorm v1.30.0
+	github.com/ncruces/go-sqlite3 v0.30.3
+	gorm.io/gorm v1.31.1
 )
 
 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.9.0 // indirect
-	golang.org/x/sys v0.34.0 // indirect
-	golang.org/x/text v0.27.0 // indirect
+	github.com/tetratelabs/wazero v1.11.0 // indirect
+	golang.org/x/sys v0.39.0 // indirect
+	golang.org/x/text v0.32.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.26.3 h1:WFkQj4KNMhbqiBPGDrVpK74w1DzcxQu3wYpmdWAvfYM=
-github.com/ncruces/go-sqlite3 v0.26.3/go.mod h1:XFTPtFIo1DmGCh+XVP8KGn9b/o2f+z0WZuT09x2N6eo=
+github.com/ncruces/go-sqlite3 v0.30.3 h1:X/CgWW9GzmIAkEPrifhKqf0cC15DuOVxAJaHFTTAURQ=
+github.com/ncruces/go-sqlite3 v0.30.3/go.mod h1:AxKu9sRxkludimFocbktlY6LiYSkxiI5gTA8r+os/Nw=
 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.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
-github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
-golang.org/x/sys v0.34.0 h1:H5Y5sJ2L2JRdyv7ROF1he/lPdvFsd0mJHFw2ThKHxLA=
-golang.org/x/sys v0.34.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.27.0 h1:4fGWRpyh641NLlecmyl4LOe6yDdfaYNrGb2zdfo4JV4=
-golang.org/x/text v0.27.0/go.mod h1:1D28KMCvyooCX9hBiosv5Tz/+YLxj0j7XhWjpSUF7CU=
-gorm.io/gorm v1.30.0 h1:qbT5aPv1UH8gI99OsRlvDToLxW5zR7FzS9acZDOZcgs=
-gorm.io/gorm v1.30.0/go.mod h1:8Z33v652h4//uMA76KjeDH8mJXPm1QNCYrMeatR0DOE=
+github.com/tetratelabs/wazero v1.11.0 h1:+gKemEuKCTevU4d7ZTzlsvgd1uaToIDtlQlmNbwqYhA=
+github.com/tetratelabs/wazero v1.11.0/go.mod h1:eV28rsN8Q+xwjogd7f4/Pp4xFxO7uOGbLcD/LzB1wiU=
+golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk=
+golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/text v0.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU=
+golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY=
+gorm.io/gorm v1.31.1 h1:7CA8FTFz/gRfgqgpeKIBcervUn3xSyPUmr6B2WXJ7kg=
+gorm.io/gorm v1.31.1/go.mod h1:XyQVbO2k6YkOis7C2437jSit3SsDK72s7n7rsSHd+Gs=

gormlite/migrator.go

@@ -339,7 +339,7 @@ func (m _Migrator) GetIndexes(value interface{}) ([]gorm.Index, error) {
 	indexes := make([]gorm.Index, 0)
 	err := m.RunWithValue(value, func(stmt *gorm.Statement) error {
 		rst := make([]*_Index, 0)
-		if err := m.DB.Debug().Raw("SELECT * FROM PRAGMA_index_list(?)", stmt.Table).Scan(&rst).Error; err != nil { // alias `PRAGMA index_list(?)`
+		if err := m.DB.Raw("SELECT * FROM PRAGMA_index_list(?)", stmt.Table).Scan(&rst).Error; err != nil { // alias `PRAGMA index_list(?)`
 			return err
 		}
 		for _, index := range rst {

gormlite/sqlite_test.go

@@ -14,10 +14,10 @@ import (
 )
 
 func TestDialector(t *testing.T) {
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
 	// Custom connection with a custom function called "my_custom_function".
-	db, err := driver.Open(tmp, func(conn *sqlite3.Conn) error {
+	db, err := driver.Open(dsn, func(conn *sqlite3.Conn) error {
 		return conn.CreateFunction("my_custom_function", 0, sqlite3.DETERMINISTIC,
 			func(ctx sqlite3.Context, arg ...sqlite3.Value) {
 				ctx.ResultText("my-result")
@@ -36,14 +36,14 @@ func TestDialector(t *testing.T) {
 	}{
 		{
 			description:  "Default driver",
-			dialector:    Open(tmp),
+			dialector:    Open(dsn),
 			openSuccess:  true,
 			query:        "SELECT 1",
 			querySuccess: true,
 		},
 		{
 			description:  "Custom function",
-			dialector:    Open(tmp),
+			dialector:    Open(dsn),
 			openSuccess:  true,
 			query:        "SELECT my_custom_function()",
 			querySuccess: false,

gormlite/test.sh

@@ -7,7 +7,7 @@ rm -rf gorm/ tests/
 go work use -r .
 go test
 
-git clone --branch v1.30.0 --filter=blob:none https://github.com/go-gorm/gorm.git
+git clone --branch v1.31.1 --filter=blob:none https://github.com/go-gorm/gorm.git
 mv gorm/tests tests
 rm -rf gorm/
 

gormlite/tests.patch

@@ -7,13 +7,14 @@ diff --git a/tests/.gitignore b/tests/.gitignore
 diff --git a/tests/tests_test.go b/tests/tests_test.go
 --- a/tests/tests_test.go
 +++ b/tests/tests_test.go
-@@ -7,9 +7,11 @@ import (
+@@ -8,9 +8,11 @@ import (
  	"path/filepath"
  	"time"
  
 +	_ "github.com/ncruces/go-sqlite3/embed"
 +	sqlite "github.com/ncruces/go-sqlite3/gormlite"
 +
+ 	"gorm.io/driver/gaussdb"
  	"gorm.io/driver/mysql"
  	"gorm.io/driver/postgres"
 -	"gorm.io/driver/sqlite"

internal/alloc/alloc_unix.go

@@ -5,28 +5,36 @@ package alloc
 import (
 	"math"
 
-	"github.com/tetratelabs/wazero/experimental"
 	"golang.org/x/sys/unix"
+
+	"github.com/tetratelabs/wazero/experimental"
 )
 
-func NewMemory(_, max uint64) experimental.LinearMemory {
+func NewMemory(cap, max uint64) experimental.LinearMemory {
 	// Round up to the page size.
 	rnd := uint64(unix.Getpagesize() - 1)
-	max = (max + rnd) &^ rnd
+	res := (max + rnd) &^ rnd
 
-	if max > math.MaxInt {
-		// This ensures int(max) overflows to a negative value,
+	if res > math.MaxInt {
+		// This ensures int(res) overflows to a negative value,
 		// and unix.Mmap returns EINVAL.
-		max = math.MaxUint64
+		res = math.MaxUint64
 	}
 
-	// Reserve max bytes of address space, to ensure we won't need to move it.
+	com := res
+	prot := unix.PROT_READ | unix.PROT_WRITE
+	if cap < max { // Commit memory only if cap=max.
+		com = 0
+		prot = unix.PROT_NONE
+	}
+
+	// Reserve res bytes of address space, to ensure we won't need to move it.
 	// A protected, private, anonymous mapping should not commit memory.
-	b, err := unix.Mmap(-1, 0, int(max), unix.PROT_NONE, unix.MAP_PRIVATE|unix.MAP_ANON)
+	b, err := unix.Mmap(-1, 0, int(res), prot, unix.MAP_PRIVATE|unix.MAP_ANON)
 	if err != nil {
 		panic(err)
 	}
-	return &mmappedMemory{buf: b[:0]}
+	return &mmappedMemory{buf: b[:com]}
 }
 
 // The slice covers the entire mmapped memory:
@@ -40,9 +48,11 @@ func (m *mmappedMemory) Reallocate(size uint64) []byte {
 	com := uint64(len(m.buf))
 	res := uint64(cap(m.buf))
 	if com < size && size <= res {
-		// Round up to the page size.
+		// Grow geometrically, round up to the page size.
 		rnd := uint64(unix.Getpagesize() - 1)
-		new := (size + rnd) &^ rnd
+		new := com + com>>3
+		new = min(max(size, new), res)
+		new = (new + rnd) &^ rnd
 
 		// Commit additional memory up to new bytes.
 		err := unix.Mprotect(m.buf[com:new], unix.PROT_READ|unix.PROT_WRITE)
@@ -50,8 +60,7 @@ func (m *mmappedMemory) Reallocate(size uint64) []byte {
 			return nil
 		}
 
-		// Update committed memory.
-		m.buf = m.buf[:new]
+		m.buf = m.buf[:new] // Update committed memory.
 	}
 	// Limit returned capacity because bytes beyond
 	// len(m.buf) have not yet been committed.

internal/alloc/alloc_windows.go

@@ -5,24 +5,31 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/tetratelabs/wazero/experimental"
 	"golang.org/x/sys/windows"
+
+	"github.com/tetratelabs/wazero/experimental"
 )
 
-func NewMemory(_, max uint64) experimental.LinearMemory {
+func NewMemory(cap, max uint64) experimental.LinearMemory {
 	// Round up to the page size.
 	rnd := uint64(windows.Getpagesize() - 1)
-	max = (max + rnd) &^ rnd
+	res := (max + rnd) &^ rnd
 
-	if max > math.MaxInt {
-		// This ensures uintptr(max) overflows to a large value,
+	if res > math.MaxInt {
+		// This ensures uintptr(res) overflows to a large value,
 		// and windows.VirtualAlloc returns an error.
-		max = math.MaxUint64
+		res = math.MaxUint64
 	}
 
-	// Reserve max bytes of address space, to ensure we won't need to move it.
-	// This does not commit memory.
-	r, err := windows.VirtualAlloc(0, uintptr(max), windows.MEM_RESERVE, windows.PAGE_READWRITE)
+	com := res
+	kind := windows.MEM_COMMIT
+	if cap < max { // Commit memory only if cap=max.
+		com = 0
+		kind = windows.MEM_RESERVE
+	}
+
+	// Reserve res bytes of address space, to ensure we won't need to move it.
+	r, err := windows.VirtualAlloc(0, uintptr(res), uint32(kind), windows.PAGE_READWRITE)
 	if err != nil {
 		panic(err)
 	}
@@ -30,8 +37,9 @@ func NewMemory(_, max uint64) experimental.LinearMemory {
 	mem := virtualMemory{addr: r}
 	// SliceHeader, although deprecated, avoids a go vet warning.
 	sh := (*reflect.SliceHeader)(unsafe.Pointer(&mem.buf))
-	sh.Cap = int(max)
 	sh.Data = r
+	sh.Len = int(com)
+	sh.Cap = int(res)
 	return &mem
 }
 
@@ -47,9 +55,11 @@ func (m *virtualMemory) Reallocate(size uint64) []byte {
 	com := uint64(len(m.buf))
 	res := uint64(cap(m.buf))
 	if com < size && size <= res {
-		// Round up to the page size.
+		// Grow geometrically, round up to the page size.
 		rnd := uint64(windows.Getpagesize() - 1)
-		new := (size + rnd) &^ rnd
+		new := com + com>>3
+		new = min(max(size, new), res)
+		new = (new + rnd) &^ rnd
 
 		// Commit additional memory up to new bytes.
 		_, err := windows.VirtualAlloc(m.addr, uintptr(new), windows.MEM_COMMIT, windows.PAGE_READWRITE)
@@ -57,8 +67,7 @@ func (m *virtualMemory) Reallocate(size uint64) []byte {
 			return nil
 		}
 
-		// Update committed memory.
-		m.buf = m.buf[:new]
+		m.buf = m.buf[:new] // Update committed memory.
 	}
 	// Limit returned capacity because bytes beyond
 	// len(m.buf) have not yet been committed.

internal/util/const.go

@@ -39,6 +39,9 @@ const (
 	ERROR_MISSING_COLLSEQ   = ERROR | (1 << 8)
 	ERROR_RETRY             = ERROR | (2 << 8)
 	ERROR_SNAPSHOT          = ERROR | (3 << 8)
+	ERROR_RESERVESIZE       = ERROR | (4 << 8)
+	ERROR_KEY               = ERROR | (5 << 8)
+	ERROR_UNABLE            = ERROR | (6 << 8)
 	IOERR_READ              = IOERR | (1 << 8)
 	IOERR_SHORT_READ        = IOERR | (2 << 8)
 	IOERR_WRITE             = IOERR | (3 << 8)
@@ -73,6 +76,8 @@ const (
 	IOERR_DATA              = IOERR | (32 << 8)
 	IOERR_CORRUPTFS         = IOERR | (33 << 8)
 	IOERR_IN_PAGE           = IOERR | (34 << 8)
+	IOERR_BADKEY            = IOERR | (35 << 8)
+	IOERR_CODEC             = IOERR | (36 << 8)
 	LOCKED_SHAREDCACHE      = LOCKED | (1 << 8)
 	LOCKED_VTAB             = LOCKED | (2 << 8)
 	BUSY_RECOVERY           = BUSY | (1 << 8)

internal/util/error.go

@@ -33,8 +33,12 @@ func AssertErr() ErrorString {
 	return ErrorString(msg)
 }
 
-func ErrorCodeString(rc uint32) string {
-	switch rc {
+type errorCode interface {
+	~uint8 | ~uint16 | ~uint32 | ~int32
+}
+
+func ErrorCodeString[T errorCode](rc T) string {
+	switch uint32(rc) {
 	case ABORT_ROLLBACK:
 		return "sqlite3: abort due to ROLLBACK"
 	case ROW:
@@ -42,7 +46,7 @@ func ErrorCodeString(rc uint32) string {
 	case DONE:
 		return "sqlite3: no more rows available"
 	}
-	switch rc & 0xff {
+	switch uint8(rc) {
 	case OK:
 		return "sqlite3: not an error"
 	case ERROR:

internal/util/func.go

@@ -20,20 +20,6 @@ func ExportFuncVI[T0 i32](mod wazero.HostModuleBuilder, name string, fn func(con
 		Export(name)
 }
 
-type funcVII[T0, T1 i32] func(context.Context, api.Module, T0, T1)
-
-func (fn funcVII[T0, T1]) Call(ctx context.Context, mod api.Module, stack []uint64) {
-	_ = stack[1] // prevent bounds check on every slice access
-	fn(ctx, mod, T0(stack[0]), T1(stack[1]))
-}
-
-func ExportFuncVII[T0, T1 i32](mod wazero.HostModuleBuilder, name string, fn func(context.Context, api.Module, T0, T1)) {
-	mod.NewFunctionBuilder().
-		WithGoModuleFunction(funcVII[T0, T1](fn),
-			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32}, nil).
-		Export(name)
-}
-
 type funcVIII[T0, T1, T2 i32] func(context.Context, api.Module, T0, T1, T2)
 
 func (fn funcVIII[T0, T1, T2]) Call(ctx context.Context, mod api.Module, stack []uint64) {

internal/util/json.go

@@ -1,3 +1,5 @@
+//go:build !goexperiment.jsonv2
+
 package util
 
 import (

internal/util/json_v2.go

@@ -0,0 +1,52 @@
+//go:build goexperiment.jsonv2
+
+package util
+
+import (
+	"encoding/json/v2"
+	"math"
+	"strconv"
+	"time"
+	"unsafe"
+)
+
+type JSON struct{ Value any }
+
+func (j JSON) Scan(value any) error {
+	var buf []byte
+
+	switch v := value.(type) {
+	case []byte:
+		buf = v
+	case string:
+		buf = unsafe.Slice(unsafe.StringData(v), len(v))
+	case int64:
+		buf = strconv.AppendInt(nil, v, 10)
+	case float64:
+		buf = AppendNumber(nil, v)
+	case time.Time:
+		buf = append(buf, '"')
+		buf = v.AppendFormat(buf, time.RFC3339Nano)
+		buf = append(buf, '"')
+	case nil:
+		buf = []byte("null")
+	default:
+		panic(AssertErr())
+	}
+
+	return json.Unmarshal(buf, j.Value)
+}
+
+func AppendNumber(dst []byte, f float64) []byte {
+	switch {
+	case math.IsNaN(f):
+		dst = append(dst, "null"...)
+	case math.IsInf(f, 1):
+		dst = append(dst, "9.0e999"...)
+	case math.IsInf(f, -1):
+		dst = append(dst, "-9.0e999"...)
+	default:
+		return strconv.AppendFloat(dst, f, 'g', -1, 64)
+	}
+	return dst
+}

internal/util/mmap_unix.go

@@ -7,8 +7,9 @@ import (
 	"os"
 	"unsafe"
 
-	"github.com/tetratelabs/wazero/api"
 	"golang.org/x/sys/unix"
+
+	"github.com/tetratelabs/wazero/api"
 )
 
 type mmapState struct {

internal/util/mmap_windows.go

@@ -1,12 +1,10 @@
 package util
 
 import (
-	"context"
 	"os"
 	"reflect"
 	"unsafe"
 
-	"github.com/tetratelabs/wazero/api"
 	"golang.org/x/sys/windows"
 )
 
@@ -16,14 +14,21 @@ type MappedRegion struct {
 	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)
+func MapRegion(f *os.File, offset int64, size int32) (*MappedRegion, error) {
+	maxSize := offset + int64(size)
+	h, err := windows.CreateFileMapping(
+		windows.Handle(f.Fd()), nil, windows.PAGE_READWRITE,
+		uint32(maxSize>>32), uint32(maxSize), nil)
 	if h == 0 {
 		return nil, err
 	}
 
+	const allocationGranularity = 64 * 1024
+	align := offset % allocationGranularity
+	offset -= align
+
 	a, err := windows.MapViewOfFile(h, windows.FILE_MAP_WRITE,
-		uint32(offset>>32), uint32(offset), uintptr(size))
+		uint32(offset>>32), uint32(offset), uintptr(size)+uintptr(align))
 	if a == 0 {
 		windows.CloseHandle(h)
 		return nil, err
@@ -32,9 +37,9 @@ func MapRegion(ctx context.Context, mod api.Module, f *os.File, offset int64, si
 	ret := &MappedRegion{Handle: h, addr: a}
 	// SliceHeader, although deprecated, avoids a go vet warning.
 	sh := (*reflect.SliceHeader)(unsafe.Pointer(&ret.Data))
+	sh.Data = a + uintptr(align)
 	sh.Len = int(size)
 	sh.Cap = int(size)
-	sh.Data = a
 	return ret, nil
 }
 

internal/util/module.go

@@ -12,6 +12,7 @@ type ConnKey struct{}
 
 type moduleKey struct{}
 type moduleState struct {
+	sysError error
 	mmapState
 	handleState
 }
@@ -23,3 +24,20 @@ func NewContext(ctx context.Context) context.Context {
 	ctx = context.WithValue(ctx, moduleKey{}, state)
 	return ctx
 }
+
+func GetSystemError(ctx context.Context) error {
+	// Test needed to simplify testing.
+	s, ok := ctx.Value(moduleKey{}).(*moduleState)
+	if ok {
+		return s.sysError
+	}
+	return nil
+}
+
+func SetSystemError(ctx context.Context, err error) {
+	// Test needed to simplify testing.
+	s, ok := ctx.Value(moduleKey{}).(*moduleState)
+	if ok {
+		s.sysError = err
+	}
+}

json.go

@@ -1,6 +1,13 @@
+//go:build !goexperiment.jsonv2
+
 package sqlite3
 
-import "github.com/ncruces/go-sqlite3/internal/util"
+import (
+	"encoding/json"
+	"strconv"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+)
 
 // JSON returns a value that can be used as an argument to
 // [database/sql.DB.Exec], [database/sql.Row.Scan] and similar methods to
@@ -10,3 +17,77 @@ import "github.com/ncruces/go-sqlite3/internal/util"
 func JSON(value any) any {
 	return util.JSON{Value: value}
 }
+
+// ResultJSON sets the result of the function to the JSON encoding of value.
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultJSON(value any) {
+	err := json.NewEncoder(callbackWriter(func(p []byte) (int, error) {
+		ctx.ResultRawText(p[:len(p)-1]) // remove the newline
+		return 0, nil
+	})).Encode(value)
+
+	if err != nil {
+		ctx.ResultError(err)
+		return // notest
+	}
+}
+
+// BindJSON binds the JSON encoding of value to the prepared statement.
+// The leftmost SQL parameter has an index of 1.
+//
+// https://sqlite.org/c3ref/bind_blob.html
+func (s *Stmt) BindJSON(param int, value any) error {
+	return json.NewEncoder(callbackWriter(func(p []byte) (int, error) {
+		return 0, s.BindRawText(param, p[:len(p)-1]) // remove the newline
+	})).Encode(value)
+}
+
+// ColumnJSON parses the JSON-encoded value of the result column
+// and stores it in the value pointed to by ptr.
+// The leftmost column of the result set has the index 0.
+//
+// https://sqlite.org/c3ref/column_blob.html
+func (s *Stmt) ColumnJSON(col int, ptr any) error {
+	var data []byte
+	switch s.ColumnType(col) {
+	case NULL:
+		data = []byte("null")
+	case TEXT:
+		data = s.ColumnRawText(col)
+	case BLOB:
+		data = s.ColumnRawBlob(col)
+	case INTEGER:
+		data = strconv.AppendInt(nil, s.ColumnInt64(col), 10)
+	case FLOAT:
+		data = util.AppendNumber(nil, s.ColumnFloat(col))
+	default:
+		panic(util.AssertErr())
+	}
+	return json.Unmarshal(data, ptr)
+}
+
+// JSON parses a JSON-encoded value
+// and stores the result in the value pointed to by ptr.
+func (v Value) JSON(ptr any) error {
+	var data []byte
+	switch v.Type() {
+	case NULL:
+		data = []byte("null")
+	case TEXT:
+		data = v.RawText()
+	case BLOB:
+		data = v.RawBlob()
+	case INTEGER:
+		data = strconv.AppendInt(nil, v.Int64(), 10)
+	case FLOAT:
+		data = util.AppendNumber(nil, v.Float())
+	default:
+		panic(util.AssertErr())
+	}
+	return json.Unmarshal(data, ptr)
+}
+
+type callbackWriter func(p []byte) (int, error)
+
+func (fn callbackWriter) Write(p []byte) (int, error) { return fn(p) }

json_v2.go

@@ -0,0 +1,113 @@
+//go:build goexperiment.jsonv2
+
+package sqlite3
+
+import (
+	"encoding/json/v2"
+	"strconv"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+)
+
+// JSON returns a value that can be used as an argument to
+// [database/sql.DB.Exec], [database/sql.Row.Scan] and similar methods to
+// store value as JSON, or decode JSON into value.
+// JSON should NOT be used with [Stmt.BindJSON], [Stmt.ColumnJSON],
+// [Value.JSON], or [Context.ResultJSON].
+func JSON(value any) any {
+	return util.JSON{Value: value}
+}
+
+// ResultJSON sets the result of the function to the JSON encoding of value.
+//
+// https://sqlite.org/c3ref/result_blob.html
+func (ctx Context) ResultJSON(value any) {
+	w := bytesWriter{sqlite: ctx.c.sqlite}
+	if err := json.MarshalWrite(&w, value); err != nil {
+		ctx.c.free(w.ptr)
+		ctx.ResultError(err)
+		return // notest
+	}
+	ctx.c.call("sqlite3_result_text_go",
+		stk_t(ctx.handle), stk_t(w.ptr), stk_t(len(w.buf)))
+}
+
+// BindJSON binds the JSON encoding of value to the prepared statement.
+// The leftmost SQL parameter has an index of 1.
+//
+// https://sqlite.org/c3ref/bind_blob.html
+func (s *Stmt) BindJSON(param int, value any) error {
+	w := bytesWriter{sqlite: s.c.sqlite}
+	if err := json.MarshalWrite(&w, value); err != nil {
+		s.c.free(w.ptr)
+		return err
+	}
+	rc := res_t(s.c.call("sqlite3_bind_text_go",
+		stk_t(s.handle), stk_t(param),
+		stk_t(w.ptr), stk_t(len(w.buf))))
+	return s.c.error(rc)
+}
+
+// ColumnJSON parses the JSON-encoded value of the result column
+// and stores it in the value pointed to by ptr.
+// The leftmost column of the result set has the index 0.
+//
+// https://sqlite.org/c3ref/column_blob.html
+func (s *Stmt) ColumnJSON(col int, ptr any) error {
+	var data []byte
+	switch s.ColumnType(col) {
+	case NULL:
+		data = []byte("null")
+	case TEXT:
+		data = s.ColumnRawText(col)
+	case BLOB:
+		data = s.ColumnRawBlob(col)
+	case INTEGER:
+		data = strconv.AppendInt(nil, s.ColumnInt64(col), 10)
+	case FLOAT:
+		data = util.AppendNumber(nil, s.ColumnFloat(col))
+	default:
+		panic(util.AssertErr())
+	}
+	return json.Unmarshal(data, ptr)
+}
+
+// JSON parses a JSON-encoded value
+// and stores the result in the value pointed to by ptr.
+func (v Value) JSON(ptr any) error {
+	var data []byte
+	switch v.Type() {
+	case NULL:
+		data = []byte("null")
+	case TEXT:
+		data = v.RawText()
+	case BLOB:
+		data = v.RawBlob()
+	case INTEGER:
+		data = strconv.AppendInt(nil, v.Int64(), 10)
+	case FLOAT:
+		data = util.AppendNumber(nil, v.Float())
+	default:
+		panic(util.AssertErr())
+	}
+	return json.Unmarshal(data, ptr)
+}
+
+type bytesWriter struct {
+	*sqlite
+	buf []byte
+	ptr ptr_t
+}
+
+func (b *bytesWriter) Write(p []byte) (n int, err error) {
+	if len(p) > cap(b.buf)-len(b.buf) {
+		want := int64(len(b.buf)) + int64(len(p))
+		grow := int64(cap(b.buf))
+		grow += grow >> 1
+		want = max(want, grow)
+		b.ptr = b.realloc(b.ptr, want)
+		b.buf = util.View(b.mod, b.ptr, want)[:len(b.buf)]
+	}
+	b.buf = append(b.buf, p...)
+	return len(p), nil
+}

registry.go

@@ -14,8 +14,8 @@ var (
 // https://sqlite.org/c3ref/auto_extension.html
 func AutoExtension(entryPoint func(*Conn) error) {
 	extRegistryMtx.Lock()
-	defer extRegistryMtx.Unlock()
 	extRegistry = append(extRegistry, entryPoint)
+	extRegistryMtx.Unlock()
 }
 
 func initExtensions(c *Conn) error {

sqlite.go

@@ -5,11 +5,14 @@ import (
 	"context"
 	"math/bits"
 	"os"
+	"runtime"
+	"strings"
 	"sync"
 	"unsafe"
 
 	"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"
@@ -78,7 +81,9 @@ func compileSQLite() {
 		return
 	}
 
-	instance.compiled, instance.err = instance.runtime.CompileModule(ctx, bin)
+	instance.compiled, instance.err = instance.runtime.CompileModule(
+		experimental.WithCompilationWorkers(ctx, runtime.GOMAXPROCS(0)/4),
+		bin)
 }
 
 type sqlite struct {
@@ -124,14 +129,14 @@ func (sqlt *sqlite) error(rc res_t, handle ptr_t, sql ...string) error {
 		panic(util.OOMErr)
 	}
 
+	var msg, query string
 	if handle != 0 {
-		var msg, query string
 		if ptr := ptr_t(sqlt.call("sqlite3_errmsg", stk_t(handle))); ptr != 0 {
 			msg = util.ReadString(sqlt.mod, ptr, _MAX_LENGTH)
-			switch {
-			case msg == "not an error":
-				msg = ""
-			case msg == util.ErrorCodeString(uint32(rc))[len("sqlite3: "):]:
+			msg = strings.TrimPrefix(msg, "sqlite3: ")
+			msg = strings.TrimPrefix(msg, util.ErrorCodeString(rc)[len("sqlite3: "):])
+			msg = strings.TrimPrefix(msg, ": ")
+			if msg == "" || msg == "not an error" {
 				msg = ""
 			}
 		}
@@ -141,10 +146,16 @@ func (sqlt *sqlite) error(rc res_t, handle ptr_t, sql ...string) error {
 				query = sql[0][i:]
 			}
 		}
+	}
 
-		if msg != "" || query != "" {
-			return &Error{code: rc, msg: msg, sql: query}
-		}
+	var sys error
+	switch ErrorCode(rc) {
+	case CANTOPEN, IOERR:
+		sys = util.GetSystemError(sqlt.ctx)
+	}
+
+	if sys != nil || msg != "" || query != "" {
+		return &Error{code: rc, sys: sys, msg: msg, sql: query}
 	}
 	return xErrorCode(rc)
 }

sqlite3/busy_timeout.patch

@@ -2,7 +2,7 @@
 # handle, and interrupt, sqlite3_busy_timeout.
 --- sqlite3.c.orig
 +++ sqlite3.c
-@@ -184447,7 +184447,7 @@
+@@ -186667,7 +186667,7 @@
    if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
  #endif
    if( ms>0 ){

sqlite3/download.sh

@@ -3,46 +3,54 @@ set -euo pipefail
 
 cd -P -- "$(dirname -- "$0")"
 
-curl -#OL "https://sqlite.org/2025/sqlite-amalgamation-3500300.zip"
-unzip -d . sqlite-amalgamation-*.zip
-mv sqlite-amalgamation-*/sqlite3.c .
-mv sqlite-amalgamation-*/sqlite3.h .
-mv sqlite-amalgamation-*/sqlite3ext.h .
-rm -rf sqlite-amalgamation-*
+curl -#OL "https://sqlite.org/2025/sqlite-autoconf-3510100.tar.gz"
 
-# To test a snapshot:
+# Verify download.
+if hash=$(openssl dgst -sha3-256 sqlite-autoconf-*.tar.gz); then
+  if ! [[ $hash =~ 9b2b1e73f577def1d5b75c5541555a7f42e6e073ad19f7a9118478389c9bbd9b ]]; then
+    echo $hash
+    exit 1
+  fi
+fi 2> /dev/null
+
+tar xzf sqlite-autoconf-*.tar.gz
+
+# To test a snapshot instead:
 # 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-*
+
+mv sqlite-*/sqlite3.c .
+mv sqlite-*/sqlite3.h .
+mv sqlite-*/sqlite3ext.h .
+rm -r sqlite-*
+
+GITHUB_TAG="https://github.com/sqlite/sqlite/raw/version-3.51.1"
 
 mkdir -p ext/
 cd ext/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.3/ext/misc/anycollseq.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.3/ext/misc/base64.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.3/ext/misc/decimal.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.3/ext/misc/ieee754.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.3/ext/misc/regexp.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.3/ext/misc/series.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.3/ext/misc/spellfix.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.3/ext/misc/uint.c"
+curl -#OL "$GITHUB_TAG/ext/misc/anycollseq.c"
+curl -#OL "$GITHUB_TAG/ext/misc/base64.c"
+curl -#OL "$GITHUB_TAG/ext/misc/decimal.c"
+curl -#OL "$GITHUB_TAG/ext/misc/ieee754.c"
+curl -#OL "$GITHUB_TAG/ext/misc/regexp.c"
+curl -#OL "$GITHUB_TAG/ext/misc/series.c"
+curl -#OL "$GITHUB_TAG/ext/misc/spellfix.c"
+curl -#OL "$GITHUB_TAG/ext/misc/uint.c"
 cd ~-
 
 cd ../vfs/tests/mptest/testdata/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.3/mptest/config01.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.3/mptest/config02.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.3/mptest/crash01.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.3/mptest/crash02.subtest"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.3/mptest/multiwrite01.test"
+curl -#OL "$GITHUB_TAG/mptest/config01.test"
+curl -#OL "$GITHUB_TAG/mptest/config02.test"
+curl -#OL "$GITHUB_TAG/mptest/crash01.test"
+curl -#OL "$GITHUB_TAG/mptest/crash02.subtest"
+curl -#OL "$GITHUB_TAG/mptest/multiwrite01.test"
 cd ~-
 
 cd ../vfs/tests/mptest/wasm/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.3/mptest/mptest.c"
+curl -#OL "$GITHUB_TAG/mptest/mptest.c"
 cd ~-
 
 cd ../vfs/tests/speedtest1/wasm/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.3/test/speedtest1.c"
+curl -#OL "$GITHUB_TAG/test/speedtest1.c"
 cd ~-
 
-cat *.patch | patch -p0 --no-backup-if-mismatch
+cat *.patch | patch -p0 --no-backup-if-mismatch

sqlite3/libc/build.sh

@@ -22,7 +22,8 @@ EOF
 	-mmutable-globals -mnontrapping-fptoint \
 	-msimd128 -mbulk-memory -msign-ext \
 	-mreference-types -mmultivalue \
-	-fno-stack-protector -fno-stack-clash-protection \
+	-mno-extended-const \
+	-fno-stack-protector \
 	-Wl,-z,stack-size=4096 \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
@@ -38,14 +39,13 @@ EOF
 	-Wl,--export=strcspn \
 	-Wl,--export=strlen \
 	-Wl,--export=strrchr \
-	-Wl,--export=strspn \
-	-Wl,--export=qsort
+	-Wl,--export=strspn
 
 "$BINARYEN/wasm-ctor-eval" -g -c _initialize libc.wasm -o libc.tmp
-"$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
-	libc.tmp -o libc.wasm \
+"$BINARYEN/wasm-opt" -g libc.tmp -o libc.wasm --converge -O3 \
 	--enable-mutable-globals --enable-nontrapping-float-to-int \
 	--enable-simd --enable-bulk-memory --enable-sign-ext \
-	--enable-reference-types --enable-multivalue
+	--enable-reference-types --enable-multivalue \
+	--strip --strip-debug --strip-producers
 
 "$BINARYEN/wasm-dis" -o libc.wat libc.wasm

sqlite3/libc/libc_test.go

@@ -8,7 +8,6 @@ import (
 	"os"
 	"strings"
 	"testing"
-	"unicode/utf8"
 
 	"github.com/tetratelabs/wazero"
 	"github.com/tetratelabs/wazero/api"
@@ -76,8 +75,7 @@ func Benchmark_memset(b *testing.B) {
 	clear(memory)
 
 	b.SetBytes(size)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		call(memset, ptr1, 3, size)
 	}
 }
@@ -87,8 +85,7 @@ func Benchmark_memcpy(b *testing.B) {
 	fill(memory[ptr2:ptr2+size], 5)
 
 	b.SetBytes(size)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		call(memcpy, ptr1, ptr2, size)
 	}
 }
@@ -98,8 +95,7 @@ func Benchmark_strlen(b *testing.B) {
 	fill(memory[ptr1:ptr1+size-1], 5)
 
 	b.SetBytes(size)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		call(strlen, ptr1)
 	}
 }
@@ -110,8 +106,7 @@ func Benchmark_memchr(b *testing.B) {
 	fill(memory[ptr1+size/2:ptr1+size], 5)
 
 	b.SetBytes(size/2 + 1)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		call(memchr, ptr1, 5, size)
 	}
 }
@@ -122,8 +117,7 @@ func Benchmark_strchr(b *testing.B) {
 	fill(memory[ptr1+size/2:ptr1+size-1], 5)
 
 	b.SetBytes(size/2 + 1)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		call(strchr, ptr1, 5)
 	}
 }
@@ -134,8 +128,7 @@ func Benchmark_strrchr(b *testing.B) {
 	fill(memory[ptr1+size/2:ptr1+size-1], 7)
 
 	b.SetBytes(size/2 + 1)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		call(strrchr, ptr1, 5)
 	}
 }
@@ -147,8 +140,7 @@ func Benchmark_memcmp(b *testing.B) {
 	fill(memory[ptr2+size/2:ptr2+size], 5)
 
 	b.SetBytes(size/2 + 1)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		call(memcmp, ptr1, ptr2, size)
 	}
 }
@@ -163,8 +155,7 @@ func Benchmark_strspn(b *testing.B) {
 	memory[ptr2+3] = 9
 
 	b.SetBytes(size)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		call(strspn, ptr1, ptr2)
 	}
 }
@@ -177,8 +168,7 @@ func Benchmark_strcspn(b *testing.B) {
 	memory[ptr2+1] = 9
 
 	b.SetBytes(size)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		call(strcspn, ptr1, ptr2)
 	}
 }
@@ -750,15 +740,7 @@ func Fuzz_strspn(f *testing.F) {
 
 		s = term(s)
 		chars = term(chars)
-		want := strings.IndexFunc(s, func(r rune) bool {
-			if uint32(r) >= utf8.RuneSelf {
-				t.Skip()
-			}
-			return strings.IndexByte(chars, byte(r)) < 0
-		})
-		if want < 0 {
-			want = len(s)
-		}
+		want := indexNotByte(s, chars)
 
 		if uint32(got) != uint32(want) {
 			t.Errorf("strspn(%v, %v) = %d, want %d",
@@ -778,11 +760,6 @@ func Fuzz_strcspn(f *testing.F) {
 		if len(s) > 128 || len(chars) > 128 {
 			t.SkipNow()
 		}
-		if strings.ContainsFunc(chars, func(r rune) bool {
-			return uint32(r) >= utf8.RuneSelf
-		}) {
-			t.SkipNow()
-		}
 		copy(memory[ptr1:], s)
 		copy(memory[ptr2:], chars)
 		memory[ptr1+len(s)] = 0
@@ -792,10 +769,7 @@ func Fuzz_strcspn(f *testing.F) {
 
 		s = term(s)
 		chars = term(chars)
-		want := strings.IndexAny(s, chars)
-		if want < 0 {
-			want = len(s)
-		}
+		want := indexAnyByte(s, chars)
 
 		if uint32(got) != uint32(want) {
 			t.Errorf("strcspn(%q, %q) = %d, want %d",
@@ -838,3 +812,21 @@ func term1[T interface{ []byte | string }](s T) T {
 	}
 	return s
 }
+
+func indexNotByte(s, chars string) int {
+	for i, c := range []byte(s) {
+		if strings.IndexByte(chars, c) < 0 {
+			return i
+		}
+	}
+	return len(s)
+}
+
+func indexAnyByte(s, chars string) int {
+	for i, c := range []byte(s) {
+		if strings.IndexByte(chars, c) >= 0 {
+			return i
+		}
+	}
+	return len(s)
+}

sqlite3/libc/string.h

@@ -242,17 +242,21 @@ char *strrchr(const char *s, int c) {
 // SIMDized check which bytes are in a set (Geoff Langdale)
 // http://0x80.pl/notesen/2018-10-18-simd-byte-lookup.html
 
+// This is the same algorithm as truffle from Hyperscan:
+// https://github.com/intel/hyperscan/blob/v5.4.2/src/nfa/truffle.c#L64-L81
+// https://github.com/intel/hyperscan/blob/v5.4.2/src/nfa/trufflecompile.cpp
+
 typedef struct {
   __u8x16 lo;
   __u8x16 hi;
 } __wasm_v128_bitmap256_t;
 
 __attribute__((always_inline))
-static void __wasm_v128_setbit(__wasm_v128_bitmap256_t *bitmap, int i) {
-  uint8_t hi_nibble = (uint8_t)i >> 4;
-  uint8_t lo_nibble = (uint8_t)i & 0xf;
-  bitmap->lo[lo_nibble] |= (uint8_t)((uint32_t)1 << (hi_nibble - 0));
-  bitmap->hi[lo_nibble] |= (uint8_t)((uint32_t)1 << (hi_nibble - 8));
+static void __wasm_v128_setbit(__wasm_v128_bitmap256_t *bitmap, uint8_t i) {
+  uint8_t hi_nibble = i >> 4;
+  uint8_t lo_nibble = i & 0xf;
+  bitmap->lo[lo_nibble] |= (uint8_t)(1u << (hi_nibble - 0));
+  bitmap->hi[lo_nibble] |= (uint8_t)(1u << (hi_nibble - 8));
 }
 
 #ifndef __wasm_relaxed_simd__
@@ -264,18 +268,17 @@ static void __wasm_v128_setbit(__wasm_v128_bitmap256_t *bitmap, int i) {
 __attribute__((always_inline))
 static v128_t __wasm_v128_chkbits(__wasm_v128_bitmap256_t bitmap, v128_t v) {
   v128_t hi_nibbles = wasm_u8x16_shr(v, 4);
-  v128_t bitmask_lookup = wasm_u8x16_const(1, 2, 4, 8, 16, 32, 64, 128,  //
-                                           1, 2, 4, 8, 16, 32, 64, 128);
+  v128_t bitmask_lookup = wasm_u64x2_const_splat(0x8040201008040201);
   v128_t bitmask = wasm_i8x16_relaxed_swizzle(bitmask_lookup, hi_nibbles);
 
   v128_t indices_0_7 = v & wasm_u8x16_const_splat(0x8f);
   v128_t indices_8_15 = indices_0_7 ^ wasm_u8x16_const_splat(0x80);
 
-  v128_t row_0_7 = wasm_i8x16_swizzle(bitmap.lo, indices_0_7);
-  v128_t row_8_15 = wasm_i8x16_swizzle(bitmap.hi, indices_8_15);
+  v128_t row_0_7 = wasm_i8x16_swizzle((v128_t)bitmap.lo, indices_0_7);
+  v128_t row_8_15 = wasm_i8x16_swizzle((v128_t)bitmap.hi, indices_8_15);
 
   v128_t bitsets = row_0_7 | row_8_15;
-  return wasm_i8x16_eq(bitsets & bitmask, bitmask);
+  return bitsets & bitmask;
 }
 
 #undef wasm_i8x16_relaxed_swizzle
@@ -317,17 +320,18 @@ size_t strspn(const char *s, const char *c) {
 
   for (; *c; c++) {
     // Terminator IS NOT on the bitmap.
-    __wasm_v128_setbit(&bitmap, *c);
+    __wasm_v128_setbit(&bitmap, (uint8_t)*c);
   }
 
   for (;;) {
     v128_t v = *(v128_t *)addr;
-    v128_t cmp = __wasm_v128_chkbits(bitmap, v);
+    v128_t found = __wasm_v128_chkbits(bitmap, v);
     // Bitmask is slow on AArch64, all_true is much faster.
-    if (!wasm_i8x16_all_true(cmp)) {
+    if (!wasm_i8x16_all_true(found)) {
+      v128_t cmp = wasm_i8x16_eq(found, (v128_t){});
       // Clear the bits corresponding to align (little-endian)
       // so we can count trailing zeros.
-      int mask = (uint16_t)~wasm_i8x16_bitmask(cmp) >> align << align;
+      int mask = wasm_i8x16_bitmask(cmp) >> align << align;
       // At least one bit will be set, unless align cleared them.
       // Knowing this helps the compiler if it unrolls the loop.
       __builtin_assume(mask || align);
@@ -356,17 +360,18 @@ size_t strcspn(const char *s, const char *c) {
 
   do {
     // Terminator IS on the bitmap.
-    __wasm_v128_setbit(&bitmap, *c);
+    __wasm_v128_setbit(&bitmap, (uint8_t)*c);
   } while (*c++);
 
   for (;;) {
     v128_t v = *(v128_t *)addr;
-    v128_t cmp = __wasm_v128_chkbits(bitmap, v);
+    v128_t found = __wasm_v128_chkbits(bitmap, v);
     // Bitmask is slow on AArch64, any_true is much faster.
-    if (wasm_v128_any_true(cmp)) {
+    if (wasm_v128_any_true(found)) {
+      v128_t cmp = wasm_i8x16_eq(found, (v128_t){});
       // Clear the bits corresponding to align (little-endian)
       // so we can count trailing zeros.
-      int mask = wasm_i8x16_bitmask(cmp) >> align << align;
+      int mask = (uint16_t)~wasm_i8x16_bitmask(cmp) >> align << align;
       // At least one bit will be set, unless align cleared them.
       // Knowing this helps the compiler if it unrolls the loop.
       __builtin_assume(mask || align);

sqlite3/tools.sh

@@ -26,8 +26,8 @@ elif [[ "$OSTYPE" == "darwin"* ]]; then
   fi
 fi
 
-WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-25/wasi-sdk-25.0-$WASI_SDK.tar.gz"
-BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_123/binaryen-version_123-$BINARYEN.tar.gz"
+WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-29/wasi-sdk-29.0-$WASI_SDK.tar.gz"
+BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_125/binaryen-version_125-$BINARYEN.tar.gz"
 
 # Download tools
 mkdir -p "$ROOT/tools"

sqlite3/vfs_find.patch

@@ -1,7 +1,7 @@
 # Remove VFS registration. Go handles it.
 --- sqlite3.c.orig
 +++ sqlite3.c
-@@ -26882,7 +26882,7 @@
+@@ -27176,7 +27176,7 @@
    sqlite3_free(p);
    return sqlite3_os_init();
  }
@@ -10,7 +10,7 @@
  /*
  ** The list of all registered VFS implementations.
  */
-@@ -26979,7 +26979,7 @@
+@@ -27273,7 +27273,7 @@
    sqlite3_mutex_leave(mutex);
    return SQLITE_OK;
  }

stmt.go

@@ -1,9 +1,7 @@
 package sqlite3
 
 import (
-	"encoding/json"
 	"math"
-	"strconv"
 	"time"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
@@ -362,16 +360,6 @@ func (s *Stmt) BindPointer(param int, ptr any) error {
 	return s.c.error(rc)
 }
 
-// BindJSON binds the JSON encoding of value to the prepared statement.
-// The leftmost SQL parameter has an index of 1.
-//
-// https://sqlite.org/c3ref/bind_blob.html
-func (s *Stmt) BindJSON(param int, value any) error {
-	return json.NewEncoder(callbackWriter(func(p []byte) (int, error) {
-		return 0, s.BindRawText(param, p[:len(p)-1]) // remove the newline
-	})).Encode(value)
-}
-
 // BindValue binds a copy of value to the prepared statement.
 // The leftmost SQL parameter has an index of 1.
 //
@@ -598,30 +586,6 @@ func (s *Stmt) columnRawBytes(col int, ptr ptr_t, nul int32) []byte {
 	return util.View(s.c.mod, ptr, int64(n+nul))[:n]
 }
 
-// ColumnJSON parses the JSON-encoded value of the result column
-// and stores it in the value pointed to by ptr.
-// The leftmost column of the result set has the index 0.
-//
-// https://sqlite.org/c3ref/column_blob.html
-func (s *Stmt) ColumnJSON(col int, ptr any) error {
-	var data []byte
-	switch s.ColumnType(col) {
-	case NULL:
-		data = []byte("null")
-	case TEXT:
-		data = s.ColumnRawText(col)
-	case BLOB:
-		data = s.ColumnRawBlob(col)
-	case INTEGER:
-		data = strconv.AppendInt(nil, s.ColumnInt64(col), 10)
-	case FLOAT:
-		data = util.AppendNumber(nil, s.ColumnFloat(col))
-	default:
-		panic(util.AssertErr())
-	}
-	return json.Unmarshal(data, ptr)
-}
-
 // ColumnValue returns the unprotected value of the result column.
 // The leftmost column of the result set has the index 0.
 //
@@ -748,7 +712,3 @@ func (s *Stmt) columns(count int64) ([]byte, ptr_t, error) {
 
 	return util.View(s.c.mod, typePtr, count), dataPtr, nil
 }
-
-type callbackWriter func(p []byte) (int, error)
-
-func (fn callbackWriter) Write(p []byte) (int, error) { return fn(p) }

tests/blob_test.go

@@ -45,10 +45,7 @@ func TestBlob(t *testing.T) {
 	}
 
 	var data [1280]byte
-	_, err = rand.Read(data[:])
-	if err != nil {
-		t.Fatal(err)
-	}
+	rand.Read(data[:])
 
 	_, err = blob.Write(data[:size/2])
 	if err != nil {

tests/bradfitz/sql_test.go

@@ -35,7 +35,7 @@ type params struct {
 	*sql.DB
 }
 
-func (t params) mustExec(sql string, args ...interface{}) sql.Result {
+func (t params) mustExec(sql string, args ...any) sql.Result {
 	res, err := t.DB.Exec(sql, args...)
 	if err != nil {
 		t.Fatalf("Error running %q: %v", sql, err)

tests/config_test.go

@@ -189,13 +189,23 @@ func TestConn_FileControl(t *testing.T) {
 		}
 	})
 
+	t.Run("FCNTL_VFSNAME", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_VFSNAME)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != "os" {
+			t.Errorf(`got %q, want "os"`, o)
+		}
+	})
+
 	t.Run("FCNTL_VFS_POINTER", func(t *testing.T) {
 		o, err := db.FileControl("", sqlite3.FCNTL_VFS_POINTER)
 		if err != nil {
 			t.Fatal(err)
 		}
 		if o != vfs.Find("os") {
-			t.Errorf("got %v, want os", o)
+			t.Errorf(`got %v, want "os"`, o)
 		}
 	})
 
@@ -388,11 +398,11 @@ func TestConn_Trace(t *testing.T) {
 
 func TestConn_AutoVacuumPages(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t, url.Values{
+	dsn := memdb.TestDB(t, url.Values{
 		"_pragma": {"auto_vacuum(full)"},
 	})
 
-	db, err := sqlite3.Open(tmp)
+	db, err := sqlite3.Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}

tests/conn_test.go

@@ -12,7 +12,7 @@ import (
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
 	_ "github.com/ncruces/go-sqlite3/internal/testcfg"
-	_ "github.com/ncruces/go-sqlite3/vfs/memdb"
+	"github.com/ncruces/go-sqlite3/vfs/memdb"
 )
 
 func TestConn_Open_dir(t *testing.T) {
@@ -22,8 +22,8 @@ func TestConn_Open_dir(t *testing.T) {
 	if err == nil {
 		t.Fatal("want error")
 	}
-	if !errors.Is(err, sqlite3.CANTOPEN) {
-		t.Errorf("got %v, want sqlite3.CANTOPEN", err)
+	if !errors.Is(err, sqlite3.CANTOPEN_ISDIR) {
+		t.Errorf("got %v, want sqlite3.CANTOPEN_ISDIR", err)
 	}
 }
 
@@ -112,6 +112,48 @@ func TestConn_Close_BUSY(t *testing.T) {
 	}
 }
 
+func TestConn_BusyHandler(t *testing.T) {
+	t.Parallel()
+
+	dsn := memdb.TestDB(t)
+
+	db1, err := sqlite3.Open(dsn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db1.Close()
+
+	db2, err := sqlite3.Open(dsn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db2.Close()
+
+	var called bool
+	err = db2.BusyHandler(func(ctx context.Context, count int) (retry bool) {
+		called = true
+		return count < 1
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	tx, err := db1.BeginExclusive()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer tx.End(&err)
+
+	_, err = db2.BeginExclusive()
+	if !errors.Is(err, sqlite3.BUSY) {
+		t.Errorf("got %v, want sqlite3.BUSY", err)
+	}
+
+	if !called {
+		t.Error("busy handler not called")
+	}
+}
+
 func TestConn_SetInterrupt(t *testing.T) {
 	t.Parallel()
 
@@ -121,7 +163,7 @@ func TestConn_SetInterrupt(t *testing.T) {
 	}
 	defer db.Close()
 
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx, cancel := context.WithCancel(t.Context())
 	db.SetInterrupt(ctx)
 
 	// Interrupt doesn't interrupt this.
@@ -160,9 +202,7 @@ func TestConn_SetInterrupt(t *testing.T) {
 		t.Errorf("got %v, want sqlite3.INTERRUPT", err)
 	}
 
-	ctx, cancel = context.WithCancel(context.Background())
-	defer cancel()
-	db.SetInterrupt(ctx)
+	db.SetInterrupt(t.Context())
 
 	// Interrupting can be cleared.
 	err = db.Exec(`SELECT 1`)
@@ -170,9 +210,8 @@ func TestConn_SetInterrupt(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	db.SetInterrupt(ctx)
-	if got := db.GetInterrupt(); got != ctx {
-		t.Errorf("got %v, want %v", got, ctx)
+	if got := db.GetInterrupt(); got != t.Context() {
+		t.Errorf("got %v, want %v", got, t.Context())
 	}
 }
 

tests/driver_test.go

@@ -1,7 +1,6 @@
 package tests
 
 import (
-	"context"
 	"testing"
 
 	"github.com/ncruces/go-sqlite3"
@@ -13,12 +12,9 @@ import (
 
 func TestDriver(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	db, err := driver.Open(tmp, nil, func(c *sqlite3.Conn) error {
+	db, err := driver.Open(dsn, nil, func(c *sqlite3.Conn) error {
 		return c.Exec(`PRAGMA optimize`)
 	})
 	if err != nil {
@@ -26,13 +22,13 @@ func TestDriver(t *testing.T) {
 	}
 	defer db.Close()
 
-	conn, err := db.Conn(ctx)
+	conn, err := db.Conn(t.Context())
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer conn.Close()
 
-	res, err := conn.ExecContext(ctx,
+	res, err := conn.ExecContext(t.Context(),
 		`CREATE TABLE users (id INTEGER PRIMARY KEY NOT NULL, name VARCHAR(10))`)
 	if err != nil {
 		t.Fatal(err)
@@ -52,7 +48,7 @@ func TestDriver(t *testing.T) {
 		t.Errorf("got %d want 0", changes)
 	}
 
-	res, err = conn.ExecContext(ctx,
+	res, err = conn.ExecContext(t.Context(),
 		`INSERT INTO users (id, name) VALUES (0, 'go'), (1, 'zig'), (2, 'whatever')`)
 	if err != nil {
 		t.Fatal(err)
@@ -65,7 +61,7 @@ func TestDriver(t *testing.T) {
 		t.Errorf("got %d want 3", changes)
 	}
 
-	stmt, err := conn.PrepareContext(context.Background(),
+	stmt, err := conn.PrepareContext(t.Context(),
 		`SELECT id, name FROM users`)
 	if err != nil {
 		t.Fatal(err)

tests/json_test.go

@@ -1,7 +1,6 @@
 package tests
 
 import (
-	"context"
 	"encoding/json"
 	"math"
 	"testing"
@@ -17,31 +16,28 @@ import (
 
 func TestJSON(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	db, err := driver.Open(tmp)
+	db, err := driver.Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db.Close()
 
-	conn, err := db.Conn(ctx)
+	conn, err := db.Conn(t.Context())
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer conn.Close()
 
-	_, err = conn.ExecContext(ctx, `CREATE TABLE test (col)`)
+	_, err = conn.ExecContext(t.Context(), `CREATE TABLE test (col)`)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	reference := time.Date(2013, 10, 7, 4, 23, 19, 120_000_000, time.FixedZone("", -4*3600))
 
-	_, err = conn.ExecContext(ctx,
+	_, err = conn.ExecContext(t.Context(),
 		`INSERT INTO test (col) VALUES (?), (?), (?), (?)`,
 		nil, 1, math.Pi, reference,
 	)
@@ -49,7 +45,7 @@ func TestJSON(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	_, err = conn.ExecContext(ctx,
+	_, err = conn.ExecContext(t.Context(),
 		`INSERT INTO test (col) VALUES (?), (?), (?), (?)`,
 		sqlite3.JSON(math.Pi), sqlite3.JSON(false),
 		julianday.Format(reference), sqlite3.JSON([]string{}))
@@ -57,7 +53,7 @@ func TestJSON(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	rows, err := conn.QueryContext(ctx, "SELECT * FROM test")
+	rows, err := conn.QueryContext(t.Context(), "SELECT * FROM test")
 	if err != nil {
 		t.Fatal(err)
 	}

tests/parallel/parallel_test.go

@@ -18,6 +18,7 @@ import (
 	"github.com/ncruces/go-sqlite3/vfs"
 	_ "github.com/ncruces/go-sqlite3/vfs/adiantum"
 	"github.com/ncruces/go-sqlite3/vfs/memdb"
+	"github.com/ncruces/go-sqlite3/vfs/mvcc"
 	_ "github.com/ncruces/go-sqlite3/vfs/xts"
 )
 
@@ -98,6 +99,22 @@ func Test_memdb(t *testing.T) {
 	testIntegrity(t, name)
 }
 
+func Test_mvcc(t *testing.T) {
+	var iter int
+	if testing.Short() {
+		iter = 1000
+	} else {
+		iter = 5000
+	}
+
+	name := mvcc.TestDB(t, mvcc.Snapshot{}, url.Values{
+		"_pragma": {"busy_timeout(10000)"},
+	})
+	createDB(t, name)
+	testParallel(t, name, iter)
+	testIntegrity(t, name)
+}
+
 func Test_adiantum(t *testing.T) {
 	if !vfs.SupportsFileLocking {
 		t.Skip("skipping without locks")
@@ -312,6 +329,16 @@ func Benchmark_memdb(b *testing.B) {
 	testParallel(b, name, b.N)
 }
 
+func Benchmark_mvcc(b *testing.B) {
+	name := mvcc.TestDB(b, mvcc.Snapshot{}, url.Values{
+		"_pragma": {"busy_timeout(10000)"},
+	})
+	createDB(b, name)
+
+	b.ResetTimer()
+	testParallel(b, name, b.N)
+}
+
 func createDB(t testing.TB, name string) {
 	db, err := sqlite3.Open(name)
 	if err != nil {

tests/stmt_test.go

@@ -496,7 +496,7 @@ func TestStmt(t *testing.T) {
 		if got := stmt.ColumnBlob(0, nil); string(got) != "true" {
 			t.Errorf("got %q, want true", got)
 		}
-		var got any = 1
+		var got any
 		if err := stmt.ColumnJSON(0, &got); err != nil {
 			t.Error(err)
 		} else if got != true {

tests/time_test.go

@@ -1,7 +1,6 @@
 package tests
 
 import (
-	"context"
 	"fmt"
 	"reflect"
 	"testing"
@@ -134,37 +133,36 @@ func TestTimeFormat_Decode(t *testing.T) {
 
 func TestTimeFormat_Scanner(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	db, err := driver.Open(tmp)
+	db, err := driver.Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db.Close()
 
-	conn, err := db.Conn(ctx)
+	conn, err := db.Conn(t.Context())
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer conn.Close()
 
-	_, err = conn.ExecContext(ctx, `CREATE TABLE test (col)`)
+	_, err = conn.ExecContext(t.Context(), `CREATE TABLE test (col)`)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	reference := time.Date(2013, 10, 7, 4, 23, 19, 120_000_000, time.FixedZone("", -4*3600))
 
-	_, err = conn.ExecContext(ctx, `INSERT INTO test VALUES (?)`, sqlite3.TimeFormat7TZ.Encode(reference))
+	_, err = conn.ExecContext(t.Context(), `INSERT INTO test VALUES (?)`,
+		sqlite3.TimeFormat7TZ.Encode(reference))
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	var got time.Time
-	err = conn.QueryRowContext(ctx, "SELECT * FROM test").Scan(sqlite3.TimeFormatAuto.Scanner(&got))
+	err = conn.QueryRowContext(t.Context(), "SELECT * FROM test").
+		Scan(sqlite3.TimeFormatAuto.Scanner(&got))
 	if err != nil {
 		t.Fatal(err)
 	}

tests/txn_test.go

@@ -170,7 +170,7 @@ func TestConn_Transaction_interrupt(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx, cancel := context.WithCancel(t.Context())
 	db.SetInterrupt(ctx)
 
 	tx, err = db.BeginExclusive()
@@ -203,7 +203,7 @@ func TestConn_Transaction_interrupt(t *testing.T) {
 		t.Errorf("got %v, want sqlite3.INTERRUPT", err)
 	}
 
-	db.SetInterrupt(context.Background())
+	db.SetInterrupt(t.Context())
 	stmt, _, err := db.Prepare(`SELECT count(*) FROM test`)
 	if err != nil {
 		t.Fatal(err)
@@ -226,7 +226,7 @@ func TestConn_Transaction_interrupted(t *testing.T) {
 	}
 	defer db.Close()
 
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx, cancel := context.WithCancel(t.Context())
 	db.SetInterrupt(ctx)
 	cancel()
 
@@ -246,15 +246,15 @@ func TestConn_Transaction_interrupted(t *testing.T) {
 
 func TestConn_Transaction_busy(t *testing.T) {
 	t.Parallel()
-	tmp := memdb.TestDB(t)
+	dsn := memdb.TestDB(t)
 
-	db1, err := sqlite3.Open(tmp)
+	db1, err := sqlite3.Open(dsn)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer db1.Close()
 
-	db2, err := sqlite3.Open(tmp + "&_pragma=busy_timeout(10000)")
+	db2, err := sqlite3.Open(dsn + "&_pragma=busy_timeout(10000)")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -274,7 +274,7 @@ func TestConn_Transaction_busy(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx, cancel := context.WithCancel(t.Context())
 	db2.SetInterrupt(ctx)
 	go cancel()
 
@@ -493,7 +493,7 @@ func TestConn_Savepoint_interrupt(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx, cancel := context.WithCancel(t.Context())
 	db.SetInterrupt(ctx)
 
 	savept1 := db.Savepoint()
@@ -530,7 +530,7 @@ func TestConn_Savepoint_interrupt(t *testing.T) {
 		t.Errorf("got %v, want sqlite3.INTERRUPT", err)
 	}
 
-	db.SetInterrupt(context.Background())
+	db.SetInterrupt(t.Context())
 	stmt, _, err := db.Prepare(`SELECT count(*) FROM test`)
 	if err != nil {
 		t.Fatal(err)

time.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/ncruces/go-sqlite3/util/sql3util"
 	"github.com/ncruces/julianday"
 )
 
@@ -94,7 +95,7 @@ func (f TimeFormat) Encode(t time.Time) any {
 	case TimeFormatUnix:
 		return t.Unix()
 	case TimeFormatUnixFrac:
-		return float64(t.Unix()) + float64(t.Nanosecond())*1e-9
+		return math.FMA(1e-9, float64(t.Nanosecond()), float64(t.Unix()))
 	case TimeFormatUnixMilli:
 		return t.UnixMilli()
 	case TimeFormatUnixMicro:
@@ -157,11 +158,13 @@ func (f TimeFormat) Decode(v any) (time.Time, error) {
 
 	case TimeFormatUnix, TimeFormatUnixFrac:
 		if s, ok := v.(string); ok {
-			f, err := strconv.ParseFloat(s, 64)
-			if err != nil {
-				return time.Time{}, err
+			if i, err := strconv.ParseInt(s, 10, 64); err == nil {
+				v = i
+			} else if f, ok := sql3util.ParseFloat(s); ok {
+				v = f
+			} else {
+				return time.Time{}, util.TimeErr
 			}
-			v = f
 		}
 		switch v := v.(type) {
 		case float64:
@@ -234,8 +237,8 @@ func (f TimeFormat) Decode(v any) (time.Time, error) {
 				v = i
 				break
 			}
-			f, err := strconv.ParseFloat(s, 64)
-			if err == nil {
+			f, ok := sql3util.ParseFloat(s)
+			if ok {
 				v = f
 				break
 			}

util/ioutil/seek.go

@@ -49,7 +49,7 @@ func (s *SeekingReaderAt) Size() (int64, error) {
 	return s.r.Seek(0, io.SeekEnd)
 }
 
-// ReadAt implements [io.Closer].
+// Close implements [io.Closer].
 func (s *SeekingReaderAt) Close() error {
 	s.l.Lock()
 	defer s.l.Unlock()

util/osutil/osfs.go

@@ -23,7 +23,7 @@ func (FS) Open(name string) (fs.File, error) {
 	return os.OpenFile(name, os.O_RDONLY, 0)
 }
 
-// ReadFileFS implements [fs.StatFS].
+// Stat implements [fs.StatFS].
 func (FS) Stat(name string) (fs.FileInfo, error) {
 	return os.Stat(name)
 }

util/sql3util/arg.go

@@ -1,6 +1,10 @@
 package sql3util
 
-import "strings"
+import (
+	"strconv"
+	"strings"
+	"time"
+)
 
 // NamedArg splits an named arg into a key and value,
 // around an equals sign.
@@ -63,3 +67,124 @@ func ParseBool(s string) (b, ok bool) {
 	}
 	return false, false
 }
+
+// ParseFloat parses a decimal floating point number.
+func ParseFloat(s string) (f float64, ok bool) {
+	if strings.TrimLeft(s, "+-.0123456789Ee") != "" {
+		return
+	}
+	f, err := strconv.ParseFloat(s, 64)
+	return f, err == nil
+}
+
+// ParseTimeShift parses a time shift modifier,
+// also the output of timediff.
+//
+// https://sqlite.org/lang_datefunc.html
+func ParseTimeShift(s string) (years, months, days int, duration time.Duration, ok bool) {
+	// Sign part: ±
+	neg := strings.HasPrefix(s, "-")
+	sign := neg || strings.HasPrefix(s, "+")
+	if sign {
+		s = s[1:]
+	}
+
+	if ok = len(s) >= 5; !ok {
+		return // !ok
+	}
+
+	defer func() {
+		if neg {
+			years = -years
+			months = -months
+			days = -days
+			duration = -duration
+		}
+	}()
+
+	// Date part: YYYY-MM-DD
+	if s[4] == '-' {
+		if ok = sign && len(s) >= 10 && s[7] == '-'; !ok {
+			return // !ok
+		}
+		if years, ok = parseInt(s[0:4], 0); !ok {
+			return // !ok
+		}
+		if months, ok = parseInt(s[5:7], 12); !ok {
+			return // !ok
+		}
+		if days, ok = parseInt(s[8:10], 31); !ok {
+			return // !ok
+		}
+		if len(s) == 10 {
+			return
+		}
+		if ok = s[10] == ' '; !ok {
+			return // !ok
+		}
+		s = s[11:]
+	}
+
+	// Time part: HH:MM
+	if ok = len(s) >= 5 && s[2] == ':'; !ok {
+		return // !ok
+	}
+
+	var hours, minutes int
+	if hours, ok = parseInt(s[0:2], 24); !ok {
+		return
+	}
+	if minutes, ok = parseInt(s[3:5], 60); !ok {
+		return
+	}
+	duration = time.Duration(hours)*time.Hour + time.Duration(minutes)*time.Minute
+
+	if len(s) == 5 {
+		return
+	}
+	if ok = len(s) >= 8 && s[5] == ':'; !ok {
+		return // !ok
+	}
+
+	// Seconds part: HH:MM:SS
+	var seconds int
+	if seconds, ok = parseInt(s[6:8], 60); !ok {
+		return
+	}
+	duration += time.Duration(seconds) * time.Second
+
+	if len(s) == 8 {
+		return
+	}
+	if ok = len(s) >= 10 && s[8] == '.'; !ok {
+		return // !ok
+	}
+	s = s[9:]
+
+	// Nanosecond part: HH:MM:SS.SSS
+	var nanos int
+	if nanos, ok = parseInt(s[0:min(9, len(s))], 0); !ok {
+		return
+	}
+	for i := len(s); i < 9; i++ {
+		nanos *= 10
+	}
+	duration += time.Duration(nanos)
+
+	// Subnanosecond part.
+	if len(s) > 9 {
+		_, ok = parseInt(s[9:], 0)
+	}
+	return
+}
+
+func parseInt(s string, max int) (i int, _ bool) {
+	for _, r := range []byte(s) {
+		r -= '0'
+		if r > 9 {
+			return
+		}
+		i = i*10 + int(r)
+	}
+	return i, max == 0 || i < max
+}

util/sql3util/arg_test.go

@@ -2,7 +2,10 @@ package sql3util_test
 
 import (
 	"testing"
+	"time"
 
+	"github.com/ncruces/go-sqlite3"
+	_ "github.com/ncruces/go-sqlite3/embed"
 	"github.com/ncruces/go-sqlite3/util/sql3util"
 )
 
@@ -53,3 +56,112 @@ func TestParseBool(t *testing.T) {
 		})
 	}
 }
+
+func TestParseTimeShift(t *testing.T) {
+	epoch := time.Unix(0, 0)
+	tests := []struct {
+		str string
+		val time.Time
+		ok  bool
+	}{
+		{"", epoch, false},
+		{"0001-11-30", epoch, false},
+		{"+_001-11-30", epoch, false},
+		{"+0001-_1-30", epoch.AddDate(1, 0, 0), false},
+		{"+0001-11-_0", epoch.AddDate(1, 11, 0), false},
+		{"+0001-11-30", epoch.AddDate(1, 11, 30), true},
+		{"-0001-11-30", epoch.AddDate(-1, -11, -30), true},
+		{"+0001-11-30T", epoch.AddDate(1, 11, 30), false},
+		{"+0001-11-30 12", epoch.AddDate(1, 11, 30), false},
+		{"+0001-11-30 _2:30", epoch.AddDate(1, 11, 30), false},
+		{"+0001-11-30 12:_0", epoch.AddDate(1, 11, 30), false},
+		{"+0001-11-30 12:30", epoch.AddDate(1, 11, 30).Add(12*time.Hour + 30*time.Minute), true},
+		{"+0001-11-30 12:30:", epoch.AddDate(1, 11, 30).Add(12*time.Hour + 30*time.Minute), false},
+		{"+0001-11-30 12:30:_0", epoch.AddDate(1, 11, 30).Add(12*time.Hour + 30*time.Minute), false},
+		{"+0001-11-30 12:30:59", epoch.AddDate(1, 11, 30).Add(12*time.Hour + 30*time.Minute + 59*time.Second), true},
+		{"+0001-11-30 12:30:59.", epoch.AddDate(1, 11, 30).Add(12*time.Hour + 30*time.Minute + 59*time.Second), false},
+		{"+0001-11-30 12:30:59._", epoch.AddDate(1, 11, 30).Add(12*time.Hour + 30*time.Minute + 59*time.Second), false},
+		{"+0001-11-30 12:30:59.1", epoch.AddDate(1, 11, 30).Add(12*time.Hour + 30*time.Minute + 59*time.Second + 100*time.Millisecond), true},
+		{"+0001-11-30 12:30:59.123456789_", epoch.AddDate(1, 11, 30).Add(12*time.Hour + 30*time.Minute + 59*time.Second + 123456789), false},
+		{"+0001-11-30 12:30:59.1234567890", epoch.AddDate(1, 11, 30).Add(12*time.Hour + 30*time.Minute + 59*time.Second + 123456789), true},
+		{"-12:30:59.1234567890", epoch.Add(-12*time.Hour - 30*time.Minute - 59*time.Second - 123456789), true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.str, func(t *testing.T) {
+			years, months, days, duration, gotOK := sql3util.ParseTimeShift(tt.str)
+			gotVal := epoch.AddDate(years, months, days).Add(duration)
+			if !gotVal.Equal(tt.val) || gotOK != tt.ok {
+				t.Errorf("ParseTimeShift(%q) = (%v, %v) want (%v, %v)", tt.str, gotVal, gotOK, tt.val, tt.ok)
+			}
+		})
+	}
+}
+
+func FuzzParseTimeShift(f *testing.F) {
+	f.Add("")
+	f.Add("0001-12-30")
+	f.Add("+_001-12-30")
+	f.Add("+0001-_2-30")
+	f.Add("+0001-12-_0")
+	f.Add("+0001-12-30")
+	f.Add("-0001-12-30")
+	f.Add("+0001-12-30T")
+	f.Add("+0001-12-30 12")
+	f.Add("+0001-12-30 _2:30")
+	f.Add("+0001-12-30 12:_0")
+	f.Add("+0001-12-30 12:30")
+	f.Add("+0001-12-30 12:30:")
+	f.Add("+0001-12-30 12:30:_0")
+	f.Add("+0001-12-30 12:30:60")
+	f.Add("+0001-12-30 12:30:60.")
+	f.Add("+0001-12-30 12:30:60._")
+	f.Add("+0001-12-30 12:30:60.1")
+	f.Add("+0001-12-30 12:30:60.123456789_")
+	f.Add("+0001-12-30 12:30:60.1234567890")
+	f.Add("-12:30:60.1234567890")
+
+	c, err := sqlite3.Open(":memory:")
+	if err != nil {
+		f.Fatal(err)
+	}
+	defer c.Close()
+
+	s, _, err := c.Prepare(`SELECT julianday('00:00', ?)`)
+	if err != nil {
+		f.Fatal(err)
+	}
+	defer s.Close()
+
+	// Default SQLite date.
+	epoch := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
+
+	f.Fuzz(func(t *testing.T, str string) {
+		years, months, days, duration, ok := sql3util.ParseTimeShift(str)
+
+		// Account for a full 400 year cycle.
+		if years < -200 || years > +200 {
+			t.Skip()
+		}
+		// SQLite only tracks milliseconds.
+		if duration != duration.Truncate(time.Millisecond) {
+			t.Skip()
+		}
+
+		if ok {
+			s.Reset()
+			s.BindText(1, str)
+			if !s.Step() {
+				t.Fail()
+			}
+
+			got := epoch.AddDate(years, months, days).Add(duration)
+
+			// Julian day introduces floating point inaccuracy.
+			want := s.ColumnTime(0, sqlite3.TimeFormatJulianDay)
+			want = want.Round(time.Millisecond)
+			if !got.Equal(want) {
+				t.Fatalf("with %q, got %v, want %v", str, got, want)
+			}
+		}
+	})
+}

util/sql3util/const.go

@@ -59,3 +59,11 @@ const (
 	ALTER_ADD_COLUMN
 	ALTER_DROP_COLUMN
 )
+
+type GenType uint32
+
+const (
+	GENTYPE_NONE GenType = iota
+	GENTYPE_STORED
+	GENTYPE_VIRTUA
+)

util/sql3util/parse.go

@@ -125,6 +125,8 @@ type Column struct {
 	DefaultExpr           string
 	CollateName           string
 	ForeignKeyClause      *ForeignKey
+	GeneratedExpr         string
+	GeneratedType         GenType
 }
 
 func (c *Column) load(mod api.Module, ptr uint32, sql string) {
@@ -152,6 +154,9 @@ func (c *Column) load(mod api.Module, ptr uint32, sql string) {
 		c.ForeignKeyClause = &ForeignKey{}
 		c.ForeignKeyClause.load(mod, ptr, sql)
 	}
+
+	c.GeneratedExpr = loadString(mod, ptr+88, sql)
+	c.GeneratedType = loadEnum[GenType](mod, ptr+96)
 }
 
 type ForeignKey struct {

util/sql3util/wasm/build.sh

@@ -17,14 +17,16 @@ trap 'rm -f sql3parse_table.tmp' EXIT
 	-mmutable-globals -mnontrapping-fptoint \
 	-msimd128 -mbulk-memory -msign-ext \
 	-mreference-types -mmultivalue \
-	-fno-stack-protector -fno-stack-clash-protection \
+	-mno-extended-const \
+	-fno-stack-protector \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
 	-Wl,--export=sql3parse_table
 
 "$BINARYEN/wasm-ctor-eval" -c _initialize sql3parse_table.wasm -o sql3parse_table.tmp
-"$BINARYEN/wasm-opt" --strip --strip-debug --strip-producers -c -Oz \
-	sql3parse_table.tmp -o sql3parse_table.wasm --low-memory-unused \
+"$BINARYEN/wasm-opt" sql3parse_table.tmp -o sql3parse_table.wasm \
+	--gufa --generate-global-effects --converge -Oz \
 	--enable-mutable-globals --enable-nontrapping-float-to-int \
 	--enable-simd --enable-bulk-memory --enable-sign-ext \
-	--enable-reference-types --enable-multivalue
+	--enable-reference-types --enable-multivalue \
+	--strip --strip-producers