Locking improvements.

Bumps [github.com/tetratelabs/wazero](https://github.com/tetratelabs/wazero) from 1.7.0-pre.1 to 1.7.0.
- [Release notes](https://github.com/tetratelabs/wazero/releases)
- [Commits](https://github.com/tetratelabs/wazero/compare/v1.7.0-pre.1...v1.7.0)

---
updated-dependencies:
- dependency-name: github.com/tetratelabs/wazero
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

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

.github/workflows/bsd.yml

@@ -1,31 +0,0 @@
-name: BSD
-
-on:
-  workflow_dispatch:
-
-jobs:
-  test:
-    runs-on: macos-12
-
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        lfs: 'true'
-
-    - name: Set up
-      uses: actions/setup-go@v5
-      with:
-        go-version: stable
-
-    - name: Build
-      run: .github/workflows/bsd.sh
-
-    - name: Test
-      uses: cross-platform-actions/action@v0.22.0
-      with:
-        operating_system: freebsd
-        version: '13.2'
-        memory: 8G
-        shell: bash
-        sync_files: runner-to-vm
-        run: source test.sh

.github/workflows/cpu.yml

@@ -1,56 +0,0 @@
-name: CPUs
-
-on:
-  workflow_dispatch:
-
-jobs:
-  test-386:
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        lfs: 'true'
-
-    - name: Set up
-      uses: actions/setup-go@v5
-      with:
-        go-version: stable
-
-    - name: Test
-      run: GOARCH=386 go test -v -short ./...
-
-  test-arm:
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        lfs: 'true'
-
-    - name: Set up
-      uses: actions/setup-go@v5
-      with:
-        go-version: stable
-
-    - name: Install QEMU
-      uses: docker/setup-qemu-action@v3
-
-    - name: Test
-      run: GOARCH=arm64 go test -v -short ./...
-
-  test-m1:
-    runs-on: macos-14
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          lfs: 'true'
-
-      - name: Set up
-        uses: actions/setup-go@v5
-        with:
-          go-version: stable
-
-      - name: Test
-        run: go test -v ./...

.github/workflows/cross.yml

@@ -10,8 +10,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4
 
-    - name: Set up
-      uses: actions/setup-go@v5
+    - uses: actions/setup-go@v5
       with:
         go-version: stable
 

.github/workflows/go.yml

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

.github/workflows/repro.sh

@@ -3,13 +3,13 @@ set -euo pipefail
 
 if [[ "$OSTYPE" == "linux"* ]]; then
   WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-21/wasi-sdk-21.0-linux.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_116/binaryen-version_116-x86_64-linux.tar.gz"
+  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_117/binaryen-version_117-x86_64-linux.tar.gz"
 elif [[ "$OSTYPE" == "darwin"* ]]; then
   WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-21/wasi-sdk-21.0-macos.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_116/binaryen-version_116-x86_64-macos.tar.gz"
+  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_117/binaryen-version_117-x86_64-macos.tar.gz"
 elif [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" ]]; then
   WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-21/wasi-sdk-21.0.m-mingw.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_116/binaryen-version_116-x86_64-windows.tar.gz"
+  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_117/binaryen-version_117-x86_64-windows.tar.gz"
 fi
 
 # Download tools

.github/workflows/repro.yml

@@ -15,8 +15,7 @@ jobs:
       with:
         lfs: 'true'
 
-    - name: Set up
-      uses: actions/setup-go@v5
+    - uses: actions/setup-go@v5
       with:
         go-version: stable
 

.github/workflows/test.yml

@@ -0,0 +1,129 @@
+name: Test
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  workflow_dispatch:
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        os: [macos-latest, ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+
+    steps:
+    - uses: actions/checkout@v4
+      with: { lfs: 'true' }
+
+    - uses: actions/setup-go@v5
+      with: { go-version: stable }
+
+    - name: Format
+      run: gofmt -s -w . && git diff --exit-code
+      if: matrix.os != 'windows-latest'
+
+    - name: Tidy
+      run: go mod tidy && git diff --exit-code
+
+    - name: Download
+      run: go mod download
+
+    - name: Verify
+      run: go mod verify
+
+    - name: Vet
+      run: go vet ./...
+
+    - name: Build
+      run: go build -v ./...
+
+    - name: Test
+      run: go test -v ./...
+
+    - name: Test BSD locks
+      run: go test -v -tags sqlite3_flock ./...
+      if: matrix.os == 'macos-latest'
+
+    - name: Test no locks
+      run: go test -v -tags sqlite3_nosys ./tests -run TestDB_nolock
+
+    - name: Test GORM
+      run: gormlite/test.sh
+
+    - uses: ncruces/go-coverage-report@v0
+      with:
+        chart: true
+        amend: true
+      if: |
+        github.event_name == 'push' &&
+        matrix.os == 'ubuntu-latest'
+
+  test-bsd:
+    runs-on: ubuntu-latest
+    needs: test
+
+    steps:
+    - uses: actions/checkout@v4
+      with: { lfs: 'true' }
+
+    - uses: actions/setup-go@v5
+      with: { go-version: stable }
+
+    - name: Build
+      run: .github/workflows/bsd.sh
+
+    - name: Test
+      uses: cross-platform-actions/action@v0.23.0
+      with:
+        operating_system: freebsd
+        version: '14.0'
+        shell: bash
+        run: source test.sh
+        sync_files: runner-to-vm
+
+  test-m1:
+    runs-on: macos-14
+    needs: test
+
+    steps:
+    - uses: actions/checkout@v4
+      with: { lfs: 'true' }
+
+    - uses: actions/setup-go@v5
+      with: { go-version: stable }
+
+    - name: Test
+      run: go test -v ./...
+
+  test-386:
+    runs-on: ubuntu-latest
+    needs: test
+
+    steps:
+    - uses: actions/checkout@v4
+      with: { lfs: 'true' }
+
+    - uses: actions/setup-go@v5
+      with: { go-version: stable }
+
+    - name: Test
+      run: GOARCH=386 go test -v -short ./...
+
+  test-arm:
+    runs-on: ubuntu-latest
+    needs: test
+
+    steps:
+    - uses: actions/checkout@v4
+      with: { lfs: 'true' }
+
+    - uses: actions/setup-go@v5
+      with: { go-version: stable }
+
+    - uses: docker/setup-qemu-action@v3
+
+    - name: Test
+      run: GOARCH=arm64 go test -v -short ./...

README.md

@@ -48,6 +48,8 @@ Go, wazero and [`x/sys`](https://pkg.go.dev/golang.org/x/sys) are the _only_ run
   provides [statistics](https://www.oreilly.com/library/view/sql-in-a/9780596155322/ch04s02.html) functions.
 - [`github.com/ncruces/go-sqlite3/ext/unicode`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/unicode)
   provides [Unicode aware](https://sqlite.org/src/dir/ext/icu) functions.
+- [`github.com/ncruces/go-sqlite3/ext/zorder`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/zorder)
+  maps multidimensional data to one dimension.
 - [`github.com/ncruces/go-sqlite3/vfs/memdb`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/memdb)
   implements an in-memory VFS.
 - [`github.com/ncruces/go-sqlite3/vfs/readervfs`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs/readervfs)
@@ -107,14 +109,13 @@ On all other platforms, file locking is not supported, and you must use
 [`nolock=1`](https://sqlite.org/uri.html#urinolock)
 (or [`immutable=1`](https://sqlite.org/uri.html#uriimmutable))
 to open database files.
+You can use [`vfs.SupportsFileLocking`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs#SupportsFileLocking)
+to check if your platform supports file locking.
 
 To use the [`database/sql`](https://pkg.go.dev/database/sql) driver
 with `nolock=1` you must disable connection pooling by calling
 [`db.SetMaxOpenConns(1)`](https://pkg.go.dev/database/sql#DB.SetMaxOpenConns).
 
-You can use [`vfs.SupportsFileLocking`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs#SupportsFileLocking)
-to check if your platform supports file locking.
-
 ### Testing
 
 This project aims for [high test coverage](https://github.com/ncruces/go-sqlite3/wiki/Test-coverage-report).

embed/README.md

@@ -5,7 +5,7 @@ This folder includes an embeddable WASM build of SQLite 3.45.1 for use with
 
 The following optional features are compiled in:
 - [math functions](https://sqlite.org/lang_mathfunc.html)
-- [FTS3/4](https://sqlite.org/fts3.html)/[5](https://sqlite.org/fts5.html)
+- [FTS5](https://sqlite.org/fts5.html)
 - [JSON](https://sqlite.org/json1.html)
 - [R*Tree](https://sqlite.org/rtree.html)
 - [GeoPoly](https://sqlite.org/geopoly.html)

embed/build.sh

@@ -4,7 +4,7 @@ set -euo pipefail
 cd -P -- "$(dirname -- "$0")"
 
 ROOT=../
-BINARYEN="$ROOT/tools/binaryen-version_116/bin"
+BINARYEN="$ROOT/tools/binaryen-version_117/bin"
 WASI_SDK="$ROOT/tools/wasi-sdk-21.0/bin"
 
 "$WASI_SDK/clang" --target=wasm32-wasi -std=c17 -flto -g0 -O2 \

ext/blobio/blob.go

@@ -128,12 +128,12 @@ func getAuxBlob(ctx sqlite3.Context, arg []sqlite3.Value, write bool) (*sqlite3.
 	return ctx.Conn().OpenBlob(db, table, column, row, write)
 }
 
-func setAuxBlob(ctx sqlite3.Context, blob *sqlite3.Blob, writer bool) {
+func setAuxBlob(ctx sqlite3.Context, blob *sqlite3.Blob, open bool) {
 	// This ensures the blob is closed if db, table, column or write change.
 	ctx.SetAuxData(0, blob) // db
 	ctx.SetAuxData(1, blob) // table
 	ctx.SetAuxData(2, blob) // column
-	if writer {
+	if open {
 		ctx.SetAuxData(4, blob) // write
 	}
 }

ext/fileio/fileio.go

@@ -22,7 +22,7 @@ func Register(db *sqlite3.Conn) {
 // and the table-valued function fsdir;
 // fsys will be used to read files and list directories.
 func RegisterFS(db *sqlite3.Conn, fsys fs.FS) {
-	db.CreateFunction("lsmode", 1, 0, lsmode)
+	db.CreateFunction("lsmode", 1, sqlite3.DETERMINISTIC, lsmode)
 	db.CreateFunction("readfile", 1, sqlite3.DIRECTONLY, readfile(fsys))
 	if fsys == nil {
 		db.CreateFunction("writefile", -1, sqlite3.DIRECTONLY, writefile)

ext/zorder/zorder.go

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

ext/zorder/zorder_test.go

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

go.mod

@@ -5,10 +5,10 @@ go 1.21
 require (
 	github.com/ncruces/julianday v1.0.0
 	github.com/psanford/httpreadat v0.1.0
-	github.com/tetratelabs/wazero v1.6.0
-	golang.org/x/crypto v0.18.0
+	github.com/tetratelabs/wazero v1.7.0
+	golang.org/x/crypto v0.21.0
 	golang.org/x/sync v0.6.0
-	golang.org/x/sys v0.16.0
+	golang.org/x/sys v0.18.0
 	golang.org/x/text v0.14.0
 )
 

go.sum

@@ -2,13 +2,13 @@ github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt
 github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
 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.6.0 h1:z0H1iikCdP8t+q341xqepY4EWvHEw8Es7tlqiVzlP3g=
-github.com/tetratelabs/wazero v1.6.0/go.mod h1:0U0G41+ochRKoPKCJlh0jMg1CHkyfK8kDqiirMmKY8A=
-golang.org/x/crypto v0.18.0 h1:PGVlW0xEltQnzFZ55hkuX5+KLyrMYhHld1YHO4AKcdc=
-golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
+github.com/tetratelabs/wazero v1.7.0 h1:jg5qPydno59wqjpGrHph81lbtHzTrWzwwtD4cD88+hQ=
+github.com/tetratelabs/wazero v1.7.0/go.mod h1:ytl6Zuh20R/eROuyDaGPkp82O9C/DJfXAwJfQ3X6/7Y=
+golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA=
+golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
 golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
 golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
-golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4=
+golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=

go.work.sum

@@ -1,3 +1,4 @@
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58=
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=

gormlite/ddlmod.go

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

gormlite/ddlmod_test.go

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

gormlite/download.sh

@@ -3,9 +3,9 @@ set -euo pipefail
 
 cd -P -- "$(dirname -- "$0")"
 
-curl -#OL "https://github.com/go-gorm/sqlite/raw/master/ddlmod.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/master/ddlmod_test.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/master/error_translator.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/master/migrator.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/master/sqlite.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/master/sqlite_test.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.5/ddlmod.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.5/ddlmod_test.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.5/error_translator.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.5/migrator.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.5/sqlite.go"
+curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.5/sqlite_test.go"

gormlite/go.mod

@@ -3,14 +3,14 @@ module github.com/ncruces/go-sqlite3/gormlite
 go 1.21
 
 require (
-	github.com/ncruces/go-sqlite3 v0.12.1
-	gorm.io/gorm v1.25.6
+	github.com/ncruces/go-sqlite3 v0.12.2
+	gorm.io/gorm v1.25.7
 )
 
 require (
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/ncruces/julianday v1.0.0 // indirect
-	github.com/tetratelabs/wazero v1.6.0 // indirect
-	golang.org/x/sys v0.16.0 // indirect
+	github.com/tetratelabs/wazero v1.7.0-pre.1 // indirect
+	golang.org/x/sys v0.18.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.12.1 h1:fxNoMQXIiMJ92B4umXyTYbNlk3xyQpZQ2S1Bojz8Z/Y=
-github.com/ncruces/go-sqlite3 v0.12.1/go.mod h1:+8dWcBxb2Yar4EcCwav1a21MpKZbztwOYBLSRYt9bMY=
+github.com/ncruces/go-sqlite3 v0.12.2 h1:NO8lFyFTA6aUtDWviQX2Rzqi1RX3X52peWq/MLgV1Gc=
+github.com/ncruces/go-sqlite3 v0.12.2/go.mod h1:+8dWcBxb2Yar4EcCwav1a21MpKZbztwOYBLSRYt9bMY=
 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.6.0 h1:z0H1iikCdP8t+q341xqepY4EWvHEw8Es7tlqiVzlP3g=
-github.com/tetratelabs/wazero v1.6.0/go.mod h1:0U0G41+ochRKoPKCJlh0jMg1CHkyfK8kDqiirMmKY8A=
-golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
-golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+github.com/tetratelabs/wazero v1.7.0-pre.1 h1:mOcomS6m5tz4gZgUaocVm0o64uDPPAmErJJmiOVLHvw=
+github.com/tetratelabs/wazero v1.7.0-pre.1/go.mod h1:ytl6Zuh20R/eROuyDaGPkp82O9C/DJfXAwJfQ3X6/7Y=
+golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4=
+golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-gorm.io/gorm v1.25.6 h1:V92+vVda1wEISSOMtodHVRcUIOPYa2tgQtyF+DfFx+A=
-gorm.io/gorm v1.25.6/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
+gorm.io/gorm v1.25.7 h1:VsD6acwRjz2zFxGO50gPO6AkNs7KKnvfzUjHQhZDz/A=
+gorm.io/gorm v1.25.7/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=

gormlite/migrator.go

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

gormlite/test.sh

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

sqlite3/date.patch

@@ -0,0 +1,556 @@
+# Backport from 3.46.
+# https://sqlite.org/draft/releaselog/current.html
+--- sqlite3.c.orig
++++ sqlite3.c
+@@ -71,13 +71,14 @@ struct DateTime {
+   int tz;             /* Timezone offset in minutes */
+   double s;           /* Seconds */
+   char validJD;       /* True (1) if iJD is valid */
+-  char rawS;          /* Raw numeric value stored in s */
+   char validYMD;      /* True (1) if Y,M,D are valid */
+   char validHMS;      /* True (1) if h,m,s are valid */
+-  char validTZ;       /* True (1) if tz is valid */
+-  char tzSet;         /* Timezone was set explicitly */
+-  char isError;       /* An overflow has occurred */
+-  char useSubsec;     /* Display subsecond precision */
++  char nFloor;            /* Days to implement "floor" */
++  unsigned rawS      : 1; /* Raw numeric value stored in s */
++  unsigned isError   : 1; /* An overflow has occurred */
++  unsigned useSubsec : 1; /* Display subsecond precision */
++  unsigned isUtc     : 1; /* Time is known to be UTC */
++  unsigned isLocal   : 1; /* Time is known to be localtime */
+ };
+ 
+ 
+@@ -175,6 +176,8 @@ static int parseTimezone(const char *zDate, DateTime *p){
+     sgn = +1;
+   }else if( c=='Z' || c=='z' ){
+     zDate++;
++    p->isLocal = 0;
++    p->isUtc = 1;
+     goto zulu_time;
+   }else{
+     return c!=0;
+@@ -187,7 +190,6 @@ static int parseTimezone(const char *zDate, DateTime *p){
+   p->tz = sgn*(nMn + nHr*60);
+ zulu_time:
+   while( sqlite3Isspace(*zDate) ){ zDate++; }
+-  p->tzSet = 1;
+   return *zDate!=0;
+ }
+ 
+@@ -231,7 +233,6 @@ static int parseHhMmSs(const char *zDate, DateTime *p){
+   p->m = m;
+   p->s = s + ms;
+   if( parseTimezone(zDate, p) ) return 1;
+-  p->validTZ = (p->tz!=0)?1:0;
+   return 0;
+ }
+ 
+@@ -278,15 +279,40 @@ static void computeJD(DateTime *p){
+   p->validJD = 1;
+   if( p->validHMS ){
+     p->iJD += p->h*3600000 + p->m*60000 + (sqlite3_int64)(p->s*1000 + 0.5);
+-    if( p->validTZ ){
++    if( p->tz ){
+       p->iJD -= p->tz*60000;
+       p->validYMD = 0;
+       p->validHMS = 0;
+-      p->validTZ = 0;
++      p->tz = 0;
++      p->isUtc = 1;
++      p->isLocal = 0;
+     }
+   }
+ }
+ 
++/*
++** Given the YYYY-MM-DD information current in p, determine if there
++** is day-of-month overflow and set nFloor to the number of days that
++** would need to be subtracted from the date in order to bring the
++** date back to the end of the month.
++*/
++static void computeFloor(DateTime *p){
++  assert( p->validYMD || p->isError );
++  assert( p->D>=0 && p->D<=31 );
++  assert( p->M>=0 && p->M<=12 );
++  if( p->D<=28 ){
++    p->nFloor = 0;
++  }else if( (1<<p->M) & 0x15aa ){
++    p->nFloor = 0;
++  }else if( p->M!=2 ){
++    p->nFloor = (p->D==31);
++  }else if( p->Y%4!=0 || (p->Y%100==0 && p->Y%400!=0) ){
++    p->nFloor = p->D - 28;
++  }else{
++    p->nFloor = p->D - 29;
++  }
++}
++
+ /*
+ ** Parse dates of the form
+ **
+@@ -325,12 +351,16 @@ static int parseYyyyMmDd(const char *zDate, DateTime *p){
+   p->Y = neg ? -Y : Y;
+   p->M = M;
+   p->D = D;
+-  if( p->validTZ ){
++  computeFloor(p);
++  if( p->tz ){
+     computeJD(p);
+   }
+   return 0;
+ }
+ 
++
++static void clearYMD_HMS_TZ(DateTime *p);  /* Forward declaration */
++
+ /*
+ ** Set the time to the current time reported by the VFS.
+ **
+@@ -340,6 +370,9 @@ static int setDateTimeToCurrent(sqlite3_context *context, DateTime *p){
+   p->iJD = sqlite3StmtCurrentTime(context);
+   if( p->iJD>0 ){
+     p->validJD = 1;
++    p->isUtc = 1;
++    p->isLocal = 0;
++    clearYMD_HMS_TZ(p);
+     return 0;
+   }else{
+     return 1;
+@@ -478,7 +511,7 @@ static void computeYMD_HMS(DateTime *p){
+ static void clearYMD_HMS_TZ(DateTime *p){
+   p->validYMD = 0;
+   p->validHMS = 0;
+-  p->validTZ = 0;
++  p->tz = 0;
+ }
+ 
+ #ifndef SQLITE_OMIT_LOCALTIME
+@@ -610,7 +643,7 @@ static int toLocaltime(
+   p->validHMS = 1;
+   p->validJD = 0;
+   p->rawS = 0;
+-  p->validTZ = 0;
++  p->tz = 0;
+   p->isError = 0;
+   return SQLITE_OK;
+ }
+@@ -630,12 +663,12 @@ static const struct {
+   float rLimit;       /* Maximum NNN value for this transform */
+   float rXform;       /* Constant used for this transform */
+ } aXformType[] = {
+-  { 6, "second", 4.6427e+14,       1.0  },
+-  { 6, "minute", 7.7379e+12,      60.0  },
+-  { 4, "hour",   1.2897e+11,    3600.0  },
+-  { 3, "day",    5373485.0,    86400.0  },
+-  { 5, "month",  176546.0,   2592000.0  },
+-  { 4, "year",   14713.0,   31536000.0  },
++  /* 0 */ { 6, "second",   4.6427e+14,         1.0  },
++  /* 1 */ { 6, "minute",   7.7379e+12,        60.0  },
++  /* 2 */ { 4, "hour",     1.2897e+11,      3600.0  },
++  /* 3 */ { 3, "day",      5373485.0,      86400.0  },
++  /* 4 */ { 5, "month",    176546.0,  30.0*86400.0  },
++  /* 5 */ { 4, "year",     14713.0,  365.0*86400.0  },
+ };
+ 
+ /*
+@@ -667,14 +700,20 @@ static void autoAdjustDate(DateTime *p){
+ **     NNN.NNNN seconds
+ **     NNN months
+ **     NNN years
++**     +/-YYYY-MM-DD HH:MM:SS.SSS
++**     ceiling
++**     floor
+ **     start of month
+ **     start of year
+ **     start of week
+ **     start of day
+ **     weekday N
+ **     unixepoch
++**     auto
+ **     localtime
+ **     utc
++**     subsec
++**     subsecond
+ **
+ ** Return 0 on success and 1 if there is any kind of error. If the error
+ ** is in a system call (i.e. localtime()), then an error message is written
+@@ -705,6 +744,37 @@ static int parseModifier(
+       }
+       break;
+     }
++    case 'c': {
++      /*
++      **    ceiling
++      **
++      ** Resolve day-of-month overflow by rolling forward into the next
++      ** month.  As this is the default action, this modifier is really
++      ** a no-op that is only included for symmetry.  See "floor".
++      */
++      if( sqlite3_stricmp(z, "ceiling")==0 ){
++        computeJD(p);
++        clearYMD_HMS_TZ(p);
++        rc = 0;
++        p->nFloor = 0;
++      }
++      break;
++    }
++    case 'f': {
++      /*
++      **    floor
++      **
++      ** Resolve day-of-month overflow by rolling back to the end of the
++      ** previous month.
++      */
++      if( sqlite3_stricmp(z, "floor")==0 ){
++        computeJD(p);
++        p->iJD -= p->nFloor*86400000;
++        clearYMD_HMS_TZ(p);
++        rc = 0;
++      }
++      break;
++    }
+     case 'j': {
+       /*
+       **    julianday
+@@ -731,7 +801,9 @@ static int parseModifier(
+       ** show local time.
+       */
+       if( sqlite3_stricmp(z, "localtime")==0 && sqlite3NotPureFunc(pCtx) ){
+-        rc = toLocaltime(p, pCtx);
++        rc = p->isLocal ? SQLITE_OK : toLocaltime(p, pCtx);
++        p->isUtc = 0;
++        p->isLocal = 1;
+       }
+       break;
+     }
+@@ -756,7 +828,7 @@ static int parseModifier(
+       }
+ #ifndef SQLITE_OMIT_LOCALTIME
+       else if( sqlite3_stricmp(z, "utc")==0 && sqlite3NotPureFunc(pCtx) ){
+-        if( p->tzSet==0 ){
++        if( p->isUtc==0 ){
+           i64 iOrigJD;              /* Original localtime */
+           i64 iGuess;               /* Guess at the corresponding utc time */
+           int cnt = 0;              /* Safety to prevent infinite loop */
+@@ -779,7 +851,8 @@ static int parseModifier(
+           memset(p, 0, sizeof(*p));
+           p->iJD = iGuess;
+           p->validJD = 1;
+-          p->tzSet = 1;
++          p->isUtc = 1;
++          p->isLocal = 0;
+         }
+         rc = SQLITE_OK;
+       }
+@@ -799,7 +872,7 @@ static int parseModifier(
+                && r>=0.0 && r<7.0 && (n=(int)r)==r ){
+         sqlite3_int64 Z;
+         computeYMD_HMS(p);
+-        p->validTZ = 0;
++        p->tz = 0;
+         p->validJD = 0;
+         computeJD(p);
+         Z = ((p->iJD + 129600000)/86400000) % 7;
+@@ -839,7 +912,7 @@ static int parseModifier(
+       p->h = p->m = 0;
+       p->s = 0.0;
+       p->rawS = 0;
+-      p->validTZ = 0;
++      p->tz = 0;
+       p->validJD = 0;
+       if( sqlite3_stricmp(z,"month")==0 ){
+         p->D = 1;
+@@ -910,6 +983,7 @@ static int parseModifier(
+         x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12;
+         p->Y += x;
+         p->M -= x*12;
++        computeFloor(p);
+         computeJD(p);
+         p->validHMS = 0;
+         p->validYMD = 0;
+@@ -956,11 +1030,12 @@ static int parseModifier(
+       z += n;
+       while( sqlite3Isspace(*z) ) z++;
+       n = sqlite3Strlen30(z);
+-      if( n>10 || n<3 ) break;
++      if( n<3 || n>10 ) break;
+       if( sqlite3UpperToLower[(u8)z[n-1]]=='s' ) n--;
+       computeJD(p);
+       assert( rc==1 );
+       rRounder = r<0 ? -0.5 : +0.5;
++      p->nFloor = 0;
+       for(i=0; i<ArraySize(aXformType); i++){
+         if( aXformType[i].nName==n
+          && sqlite3_strnicmp(aXformType[i].zName, z, n)==0
+@@ -968,21 +1043,24 @@ static int parseModifier(
+         ){
+           switch( i ){
+             case 4: { /* Special processing to add months */
+-              assert( strcmp(aXformType[i].zName,"month")==0 );
++              assert( strcmp(aXformType[4].zName,"month")==0 );
+               computeYMD_HMS(p);
+               p->M += (int)r;
+               x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12;
+               p->Y += x;
+               p->M -= x*12;
++              computeFloor(p);
+               p->validJD = 0;
+               r -= (int)r;
+               break;
+             }
+             case 5: { /* Special processing to add years */
+               int y = (int)r;
+-              assert( strcmp(aXformType[i].zName,"year")==0 );
++              assert( strcmp(aXformType[5].zName,"year")==0 );
+               computeYMD_HMS(p);
++              assert( p->M>=0 && p->M<=12 );
+               p->Y += y;
++              computeFloor(p);
+               p->validJD = 0;
+               r -= (int)r;
+               break;
+@@ -1236,22 +1314,83 @@ static void dateFunc(
+   }
+ }
+ 
++/*
++** Compute the number of days after the most recent January 1.
++**
++** In other words, compute the zero-based day number for the
++** current year:
++**
++**   Jan01 = 0,  Jan02 = 1, ..., Jan31 = 30, Feb01 = 31, ...
++**   Dec31 = 364 or 365.
++*/
++static int daysAfterJan01(DateTime *pDate){
++  DateTime jan01 = *pDate;
++  assert( jan01.validYMD );
++  assert( jan01.validHMS );
++  assert( pDate->validJD );
++  jan01.validJD = 0;
++  jan01.M = 1;
++  jan01.D = 1;
++  computeJD(&jan01);
++  return (int)((pDate->iJD-jan01.iJD+43200000)/86400000);
++}
++
++/*
++** Return the number of days after the most recent Monday.
++**
++** In other words, return the day of the week according
++** to this code:
++**
++**   0=Monday, 1=Tuesday, 2=Wednesday, ..., 6=Sunday.
++*/
++static int daysAfterMonday(DateTime *pDate){
++  assert( pDate->validJD );
++  return (int)((pDate->iJD+43200000)/86400000) % 7;
++}
++
++/*
++** Return the number of days after the most recent Sunday.
++**
++** In other words, return the day of the week according
++** to this code:
++**
++**   0=Sunday, 1=Monday, 2=Tues, ..., 6=Saturday
++*/
++static int daysAfterSunday(DateTime *pDate){
++  assert( pDate->validJD );
++  return (int)((pDate->iJD+129600000)/86400000) % 7;
++}
++
+ /*
+ **    strftime( FORMAT, TIMESTRING, MOD, MOD, ...)
+ **
+ ** Return a string described by FORMAT.  Conversions as follows:
+ **
+-**   %d  day of month
++**   %d  day of month  01-31
++**   %e  day of month  1-31
+ **   %f  ** fractional seconds  SS.SSS
++**   %F  ISO date.  YYYY-MM-DD
++**   %G  ISO year corresponding to %V 0000-9999.
++**   %g  2-digit ISO year corresponding to %V 00-99
+ **   %H  hour 00-24
+-**   %j  day of year 000-366
++**   %k  hour  0-24  (leading zero converted to space)
++**   %I  hour 01-12
++**   %j  day of year 001-366
+ **   %J  ** julian day number
++**   %l  hour  1-12  (leading zero converted to space)
+ **   %m  month 01-12
+ **   %M  minute 00-59
++**   %p  "am" or "pm"
++**   %P  "AM" or "PM"
++**   %R  time as HH:MM
+ **   %s  seconds since 1970-01-01
+ **   %S  seconds 00-59
+-**   %w  day of week 0-6  Sunday==0
+-**   %W  week of year 00-53
++**   %T  time as HH:MM:SS
++**   %u  day of week 1-7  Monday==1, Sunday==7
++**   %w  day of week 0-6  Sunday==0, Monday==1
++**   %U  week of year 00-53  (First Sunday is start of week 01)
++**   %V  week of year 01-53  (First week containing Thursday is week 01)
++**   %W  week of year 00-53  (First Monday is start of week 01)
+ **   %Y  year 0000-9999
+ **   %%  %
+ */
+@@ -1288,7 +1427,7 @@ static void strftimeFunc(
+         sqlite3_str_appendf(&sRes, cf=='d' ? "%02d" : "%2d", x.D);
+         break;
+       }
+-      case 'f': {
++      case 'f': {  /* Fractional seconds.  (Non-standard) */
+         double s = x.s;
+         if( s>59.999 ) s = 59.999;
+         sqlite3_str_appendf(&sRes, "%06.3f", s);
+@@ -1298,6 +1437,21 @@ static void strftimeFunc(
+         sqlite3_str_appendf(&sRes, "%04d-%02d-%02d", x.Y, x.M, x.D);
+         break;
+       }
++      case 'G': /* Fall thru */
++      case 'g': {
++        DateTime y = x;
++        assert( y.validJD );
++        /* Move y so that it is the Thursday in the same week as x */
++        y.iJD += (3 - daysAfterMonday(&x))*86400000;
++        y.validYMD = 0;
++        computeYMD(&y);
++        if( cf=='g' ){
++          sqlite3_str_appendf(&sRes, "%02d", y.Y%100);
++        }else{
++          sqlite3_str_appendf(&sRes, "%04d", y.Y);
++        }
++        break;
++      }
+       case 'H':
+       case 'k': {
+         sqlite3_str_appendf(&sRes, cf=='H' ? "%02d" : "%2d", x.h);
+@@ -1311,25 +1465,11 @@ static void strftimeFunc(
+         sqlite3_str_appendf(&sRes, cf=='I' ? "%02d" : "%2d", h);
+         break;
+       }
+-      case 'W': /* Fall thru */
+-      case 'j': {
+-        int nDay;             /* Number of days since 1st day of year */
+-        DateTime y = x;
+-        y.validJD = 0;
+-        y.M = 1;
+-        y.D = 1;
+-        computeJD(&y);
+-        nDay = (int)((x.iJD-y.iJD+43200000)/86400000);
+-        if( cf=='W' ){
+-          int wd;   /* 0=Monday, 1=Tuesday, ... 6=Sunday */
+-          wd = (int)(((x.iJD+43200000)/86400000)%7);
+-          sqlite3_str_appendf(&sRes,"%02d",(nDay+7-wd)/7);
+-        }else{
+-          sqlite3_str_appendf(&sRes,"%03d",nDay+1);
+-        }
++      case 'j': {  /* Day of year.  Jan01==1, Jan02==2, and so forth */
++        sqlite3_str_appendf(&sRes,"%03d",daysAfterJan01(&x)+1);
+         break;
+       }
+-      case 'J': {
++      case 'J': {  /* Julian day number.  (Non-standard) */
+         sqlite3_str_appendf(&sRes,"%.16g",x.iJD/86400000.0);
+         break;
+       }
+@@ -1372,13 +1512,33 @@ static void strftimeFunc(
+         sqlite3_str_appendf(&sRes,"%02d:%02d:%02d", x.h, x.m, (int)x.s);
+         break;
+       }
+-      case 'u': /* Fall thru */
+-      case 'w': {
+-        char c = (char)(((x.iJD+129600000)/86400000) % 7) + '0';
++      case 'u':    /* Day of week.  1 to 7.  Monday==1, Sunday==7 */
++      case 'w': {  /* Day of week.  0 to 6.  Sunday==0, Monday==1 */
++        char c = (char)daysAfterSunday(&x) + '0';
+         if( c=='0' && cf=='u' ) c = '7';
+         sqlite3_str_appendchar(&sRes, 1, c);
+         break;
+       }
++      case 'U': {  /* Week num. 00-53. First Sun of the year is week 01 */
++        sqlite3_str_appendf(&sRes,"%02d",
++              (daysAfterJan01(&x)-daysAfterSunday(&x)+7)/7);
++        break;
++      }
++      case 'V': {  /* Week num. 01-53. First week with a Thur is week 01 */
++        DateTime y = x;
++        /* Adjust y so that is the Thursday in the same week as x */
++        assert( y.validJD );
++        y.iJD += (3 - daysAfterMonday(&x))*86400000;
++        y.validYMD = 0;
++        computeYMD(&y);
++        sqlite3_str_appendf(&sRes,"%02d", daysAfterJan01(&y)/7+1);
++        break;
++      }
++      case 'W': {  /* Week num. 00-53. First Mon of the year is week 01 */
++        sqlite3_str_appendf(&sRes,"%02d",
++           (daysAfterJan01(&x)-daysAfterMonday(&x)+7)/7);
++        break;
++      }
+       case 'Y': {
+         sqlite3_str_appendf(&sRes,"%04d",x.Y);
+         break;
+@@ -1525,9 +1685,7 @@ static void timediffFunc(
+     d1.iJD = d2.iJD - d1.iJD;
+     d1.iJD += (u64)1486995408 * (u64)100000;
+   }
+-  d1.validYMD = 0;
+-  d1.validHMS = 0;
+-  d1.validTZ = 0;
++  clearYMD_HMS_TZ(&d1);
+   computeYMD_HMS(&d1);
+   sqlite3StrAccumInit(&sRes, 0, 0, 0, 100);
+   sqlite3_str_appendf(&sRes, "%c%04d-%02d-%02d %02d:%02d:%06.3f",
+@@ -1596,6 +1754,36 @@ static void currentTimeFunc(
+ }
+ #endif
+ 
++#if !defined(SQLITE_OMIT_DATETIME_FUNCS) && defined(SQLITE_DEBUG)
++/*
++**   datedebug(...)
++**
++** This routine returns JSON that describes the internal DateTime object.
++** Used for debugging and testing only.  Subject to change.
++*/
++static void datedebugFunc(
++  sqlite3_context *context,
++  int argc,
++  sqlite3_value **argv
++){
++  DateTime x;
++  if( isDate(context, argc, argv, &x)==0 ){
++    char *zJson;
++    zJson = sqlite3_mprintf(
++      "{iJD:%lld,Y:%d,M:%d,D:%d,h:%d,m:%d,tz:%d,"
++      "s:%.3f,validJD:%d,validYMS:%d,validHMS:%d,"
++      "nFloor:%d,rawS:%d,isError:%d,useSubsec:%d,"
++      "isUtc:%d,isLocal:%d}",
++      x.iJD, x.Y, x.M, x.D, x.h, x.m, x.tz,
++      x.s, x.validJD, x.validYMD, x.validHMS,
++      x.nFloor, x.rawS, x.isError, x.useSubsec,
++      x.isUtc, x.isLocal);
++    sqlite3_result_text(context, zJson, -1, sqlite3_free);
++  }
++}
++#endif /* !SQLITE_OMIT_DATETIME_FUNCS && SQLITE_DEBUG */
++
++
+ /*
+ ** This function registered all of the above C functions as SQL
+ ** functions.  This should be the only routine in this file with
+@@ -1611,6 +1799,9 @@ void sqlite3RegisterDateTimeFunctions(void){
+     PURE_DATE(datetime,         -1, 0, 0, datetimeFunc  ),
+     PURE_DATE(strftime,         -1, 0, 0, strftimeFunc  ),
+     PURE_DATE(timediff,          2, 0, 0, timediffFunc  ),
++#ifdef SQLITE_DEBUG
++    PURE_DATE(datedebug,        -1, 0, 0, datedebugFunc ),
++#endif
+     DFUNCTION(current_time,      0, 0, 0, ctimeFunc     ),
+     DFUNCTION(current_timestamp, 0, 0, 0, ctimestampFunc),
+     DFUNCTION(current_date,      0, 0, 0, cdateFunc     ),

sqlite3/download.sh

@@ -3,7 +3,7 @@ set -euo pipefail
 
 cd -P -- "$(dirname -- "$0")"
 
-curl -#OL "https://sqlite.org/2024/sqlite-amalgamation-3450100.zip"
+curl -#OL "https://sqlite.org/2024/sqlite-amalgamation-3450200.zip"
 unzip -d . sqlite-amalgamation-*.zip
 mv sqlite-amalgamation-*/sqlite3* .
 rm -rf sqlite-amalgamation-*
@@ -12,25 +12,25 @@ cat *.patch | patch --no-backup-if-mismatch
 
 mkdir -p ext/
 cd ext/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.1/ext/misc/anycollseq.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.1/ext/misc/base64.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.1/ext/misc/decimal.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.1/ext/misc/ieee754.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.1/ext/misc/regexp.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.1/ext/misc/series.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.1/ext/misc/uint.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.1/ext/misc/uuid.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.2/ext/misc/anycollseq.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.2/ext/misc/base64.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.2/ext/misc/decimal.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.2/ext/misc/ieee754.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.2/ext/misc/regexp.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.2/ext/misc/series.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.2/ext/misc/uint.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.2/ext/misc/uuid.c"
 cd ~-
 
 cd ../vfs/tests/mptest/testdata/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.1/mptest/mptest.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.1/mptest/config01.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.1/mptest/config02.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.1/mptest/crash01.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.1/mptest/crash02.subtest"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.1/mptest/multiwrite01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.2/mptest/mptest.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.2/mptest/config01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.2/mptest/config02.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.2/mptest/crash01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.2/mptest/crash02.subtest"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.2/mptest/multiwrite01.test"
 cd ~-
 
 cd ../vfs/tests/speedtest1/testdata/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.1/test/speedtest1.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.2/test/speedtest1.c"
 cd ~-

sqlite3/include.h

@@ -5,7 +5,7 @@
 
 // https://github.com/JuliaLang/julia/blob/v1.9.4/src/julia.h#L67-L68
 #define container_of(ptr, type, member) \
-  ((type *)((char *)(ptr)-offsetof(type, member)))
+  ((type *)((char *)(ptr) - offsetof(type, member)))
 
 typedef void *go_handle;
 void go_destroy(go_handle);

sqlite3/isoweek.patch

@@ -1,185 +0,0 @@
-# ISO week date specifiers, backport from 3.46.
---- sqlite3.c.orig
-+++ sqlite3.c
-@@ -25340,21 +25340,82 @@
- }
- 
- /*
-+** Compute the number of days after the most recent January 1.
-+**
-+** In other words, compute the zero-based day number for the
-+** current year:
-+**
-+**   Jan01 = 0,  Jan02 = 1, ..., Jan31 = 30, Feb01 = 31, ...
-+**   Dec31 = 364 or 365.
-+*/
-+static int daysAfterJan01(DateTime *pDate){
-+  DateTime jan01 = *pDate;
-+  assert( jan01.validYMD );
-+  assert( jan01.validHMS );
-+  assert( pDate->validJD );
-+  jan01.validJD = 0;
-+  jan01.M = 1;
-+  jan01.D = 1;
-+  computeJD(&jan01);
-+  return (int)((pDate->iJD-jan01.iJD+43200000)/86400000);
-+}
-+
-+/*
-+** Return the number of days after the most recent Monday.
-+**
-+** In other words, return the day of the week according
-+** to this code:
-+**
-+**   0=Monday, 1=Tuesday, 2=Wednesday, ..., 6=Sunday.
-+*/
-+static int daysAfterMonday(DateTime *pDate){
-+  assert( pDate->validJD );
-+  return (int)((pDate->iJD+43200000)/86400000) % 7;
-+}
-+
-+/*
-+** Return the number of days after the most recent Sunday.
-+**
-+** In other words, return the day of the week according
-+** to this code:
-+**
-+**   0=Sunday, 1=Monday, 2=Tues, ..., 6=Saturday
-+*/
-+static int daysAfterSunday(DateTime *pDate){
-+  assert( pDate->validJD );
-+  return (int)((pDate->iJD+129600000)/86400000) % 7;
-+}
-+
-+/*
- **    strftime( FORMAT, TIMESTRING, MOD, MOD, ...)
- **
- ** Return a string described by FORMAT.  Conversions as follows:
- **
--**   %d  day of month
-+**   %d  day of month  01-31
-+**   %e  day of month  1-31
- **   %f  ** fractional seconds  SS.SSS
-+**   %F  ISO date.  YYYY-MM-DD
-+**   %G  ISO year corresponding to %V 0000-9999.
-+**   %g  2-digit ISO year corresponding to %V 00-99
- **   %H  hour 00-24
--**   %j  day of year 000-366
-+**   %k  hour  0-24  (leading zero converted to space)
-+**   %I  hour 01-12
-+**   %j  day of year 001-366
- **   %J  ** julian day number
-+**   %l  hour  1-12  (leading zero converted to space)
- **   %m  month 01-12
- **   %M  minute 00-59
-+**   %p  "am" or "pm"
-+**   %P  "AM" or "PM"
-+**   %R  time as HH:MM
- **   %s  seconds since 1970-01-01
- **   %S  seconds 00-59
--**   %w  day of week 0-6  Sunday==0
--**   %W  week of year 00-53
-+**   %T  time as HH:MM:SS
-+**   %u  day of week 1-7  Monday==1, Sunday==7
-+**   %w  day of week 0-6  Sunday==0, Monday==1
-+**   %U  week of year 00-53  (First Sunday is start of week 01)
-+**   %V  week of year 01-53  (First week containing Thursday is week 01)
-+**   %W  week of year 00-53  (First Monday is start of week 01)
- **   %Y  year 0000-9999
- **   %%  %
- */
-@@ -25391,7 +25452,7 @@
-         sqlite3_str_appendf(&sRes, cf=='d' ? "%02d" : "%2d", x.D);
-         break;
-       }
--      case 'f': {
-+      case 'f': {  /* Fractional seconds.  (Non-standard) */
-         double s = x.s;
-         if( s>59.999 ) s = 59.999;
-         sqlite3_str_appendf(&sRes, "%06.3f", s);
-@@ -25401,6 +25462,21 @@
-         sqlite3_str_appendf(&sRes, "%04d-%02d-%02d", x.Y, x.M, x.D);
-         break;
-       }
-+      case 'G': /* Fall thru */
-+      case 'g': {
-+        DateTime y = x;
-+        assert( y.validJD );
-+        /* Move y so that it is the Thursday in the same week as x */
-+        y.iJD += (3 - daysAfterMonday(&x))*86400000;
-+        y.validYMD = 0;
-+        computeYMD(&y);
-+        if( cf=='g' ){
-+          sqlite3_str_appendf(&sRes, "%02d", y.Y%100);
-+        }else{
-+          sqlite3_str_appendf(&sRes, "%04d", y.Y);
-+        }
-+        break;
-+      }
-       case 'H':
-       case 'k': {
-         sqlite3_str_appendf(&sRes, cf=='H' ? "%02d" : "%2d", x.h);
-@@ -25414,25 +25490,11 @@
-         sqlite3_str_appendf(&sRes, cf=='I' ? "%02d" : "%2d", h);
-         break;
-       }
--      case 'W': /* Fall thru */
--      case 'j': {
--        int nDay;             /* Number of days since 1st day of year */
--        DateTime y = x;
--        y.validJD = 0;
--        y.M = 1;
--        y.D = 1;
--        computeJD(&y);
--        nDay = (int)((x.iJD-y.iJD+43200000)/86400000);
--        if( cf=='W' ){
--          int wd;   /* 0=Monday, 1=Tuesday, ... 6=Sunday */
--          wd = (int)(((x.iJD+43200000)/86400000)%7);
--          sqlite3_str_appendf(&sRes,"%02d",(nDay+7-wd)/7);
--        }else{
--          sqlite3_str_appendf(&sRes,"%03d",nDay+1);
--        }
-+      case 'j': {  /* Day of year.  Jan01==1, Jan02==2, and so forth */
-+        sqlite3_str_appendf(&sRes,"%03d",daysAfterJan01(&x)+1);
-         break;
-       }
--      case 'J': {
-+      case 'J': {  /* Julian day number.  (Non-standard) */
-         sqlite3_str_appendf(&sRes,"%.16g",x.iJD/86400000.0);
-         break;
-       }
-@@ -25475,11 +25537,31 @@
-         sqlite3_str_appendf(&sRes,"%02d:%02d:%02d", x.h, x.m, (int)x.s);
-         break;
-       }
--      case 'u': /* Fall thru */
--      case 'w': {
--        char c = (char)(((x.iJD+129600000)/86400000) % 7) + '0';
-+      case 'u':    /* Day of week.  1 to 7.  Monday==1, Sunday==7 */
-+      case 'w': {  /* Day of week.  0 to 6.  Sunday==0, Monday==1 */
-+        char c = (char)daysAfterSunday(&x) + '0';
-         if( c=='0' && cf=='u' ) c = '7';
-         sqlite3_str_appendchar(&sRes, 1, c);
-+        break;
-+      }
-+      case 'U': {  /* Week num. 00-53. First Sun of the year is week 01 */
-+        sqlite3_str_appendf(&sRes,"%02d",
-+              (daysAfterJan01(&x)-daysAfterSunday(&x)+7)/7);
-+        break;
-+      }
-+      case 'V': {  /* Week num. 01-53. First week with a Thur is week 01 */
-+        DateTime y = x;
-+        /* Adjust y so that is the Thursday in the same week as x */
-+        assert( y.validJD );
-+        y.iJD += (3 - daysAfterMonday(&x))*86400000;
-+        y.validYMD = 0;
-+        computeYMD(&y);
-+        sqlite3_str_appendf(&sRes,"%02d", daysAfterJan01(&y)/7+1);
-+        break;
-+      }
-+      case 'W': {  /* Week num. 00-53. First Mon of the year is week 01 */
-+        sqlite3_str_appendf(&sRes,"%02d",
-+           (daysAfterJan01(&x)-daysAfterMonday(&x)+7)/7);
-         break;
-       }
-       case 'Y': {

sqlite3/sqlite_cfg.h

@@ -9,10 +9,12 @@
 #define HAVE_INT16_T 1
 #define HAVE_INT32_T 1
 #define HAVE_INT64_T 1
+#define HAVE_INTPTR_T 1
 #define HAVE_UINT8_T 1
 #define HAVE_UINT16_T 1
 #define HAVE_UINT32_T 1
 #define HAVE_UINT64_T 1
+#define HAVE_UINTPTR_T 1
 #define HAVE_STDINT_H 1
 #define HAVE_INTTYPES_H 1
 
@@ -20,6 +22,8 @@
 #define HAVE_LOG10 1
 #define HAVE_ISNAN 1
 
+#define HAVE_STRCHRNUL 1
+
 #define HAVE_USLEEP 1
 #define HAVE_NANOSLEEP 1
 
@@ -37,6 +41,7 @@
 #define SQLITE_DEFAULT_WAL_SYNCHRONOUS 1
 #define SQLITE_LIKE_DOESNT_MATCH_BLOBS
 #define SQLITE_MAX_EXPR_DEPTH 0
+#define SQLITE_STRICT_SUBTYPE 1
 #define SQLITE_USE_ALLOCA
 #define SQLITE_OMIT_DEPRECATED
 #define SQLITE_OMIT_SHARED_CACHE
@@ -68,18 +73,12 @@
 
 #define SQLITE_ENABLE_MATH_FUNCTIONS 1
 #define SQLITE_ENABLE_JSON1 1
-#define SQLITE_ENABLE_FTS3 1
-#define SQLITE_ENABLE_FTS3_PARENTHESIS 1
-#define SQLITE_ENABLE_FTS4 1
 #define SQLITE_ENABLE_FTS5 1
 #define SQLITE_ENABLE_RTREE 1
 #define SQLITE_ENABLE_GEOPOLY 1
 
 #define SQLITE_SOUNDEX
-
-// Session Extension
-// #define SQLITE_ENABLE_SESSION
-// #define SQLITE_ENABLE_PREUPDATE_HOOK
+#define SQLITE_UNTESTABLE
 
 // Implemented in vfs.c.
 int localtime_s(struct tm *const pTm, time_t const *const pTime);

sqlite3/time.c

@@ -27,63 +27,10 @@ static int time_collation(void *pArg, int nKey1, const void *pKey1, int nKey2,
   return rc;
 }
 
-static void json_time_func(sqlite3_context *context, int argc,
-                           sqlite3_value **argv) {
-  DateTime x;
-  if (isDate(context, argc, argv, &x)) return;
-  if (x.tzSet && x.tz) {
-    x.iJD += x.tz * 60000;
-    if (!validJulianDay(x.iJD)) return;
-    x.validYMD = 0;
-    x.validHMS = 0;
-  }
-  computeYMD_HMS(&x);
-
-  sqlite3 *db = sqlite3_context_db_handle(context);
-  sqlite3_str *res = sqlite3_str_new(db);
-
-  sqlite3_str_appendf(res, "%04d-%02d-%02dT%02d:%02d:%02d",  //
-                      x.Y, x.M, x.D,                         //
-                      x.h, x.m, (int)(x.iJD / 1000 % 60));
-
-  if (x.useSubsec) {
-    int rem = x.iJD % 1000;
-    if (rem) {
-      sqlite3_str_appendchar(res, 1, '.');
-      sqlite3_str_appendchar(res, 1, '0' + rem / 100);
-      if ((rem %= 100)) {
-        sqlite3_str_appendchar(res, 1, '0' + rem / 10);
-        if ((rem %= 10)) {
-          sqlite3_str_appendchar(res, 1, '0' + rem);
-        }
-      }
-    }
-  }
-
-  if (x.tz) {
-    sqlite3_str_appendf(res, "%+03d:%02d", x.tz / 60, abs(x.tz) % 60);
-  } else {
-    sqlite3_str_appendchar(res, 1, 'Z');
-  }
-
-  int rc = sqlite3_str_errcode(res);
-  if (rc) {
-    sqlite3_result_error_code(context, rc);
-    return;
-  }
-
-  int n = sqlite3_str_length(res);
-  sqlite3_result_text(context, sqlite3_str_finish(res), n, sqlite3_free);
-}
-
 int sqlite3_time_init(sqlite3 *db, char **pzErrMsg,
                       const sqlite3_api_routines *pApi) {
   sqlite3_create_collation_v2(db, "time", SQLITE_UTF8, /*arg=*/NULL,
                               time_collation,
                               /*destroy=*/NULL);
-  sqlite3_create_function_v2(
-      db, "json_time", /*nArg=*/-1,
-      SQLITE_UTF8 | SQLITE_DETERMINISTIC | SQLITE_INNOCUOUS, /*arg=*/NULL,
-      json_time_func, /*step=*/NULL, /*final=*/NULL, /*destroy=*/NULL);
   return SQLITE_OK;
 }

sqlite3/timezone.patch

@@ -1,45 +0,0 @@
-# Set UTC timezone, compute local offset.
---- sqlite3.c.orig
-+++ sqlite3.c
-@@ -340,6 +340,7 @@ static int setDateTimeToCurrent(sqlite3_context *context, DateTime *p){
-   p->iJD = sqlite3StmtCurrentTime(context);
-   if( p->iJD>0 ){
-     p->validJD = 1;
-+    p->tzSet = 1;
-     return 0;
-   }else{
-     return 1;
-@@ -355,6 +356,7 @@ static int setDateTimeToCurrent(sqlite3_context *context, DateTime *p){
- static void setRawDateNumber(DateTime *p, double r){
-   p->s = r;
-   p->rawS = 1;
-+  p->tzSet = 1;
-   if( r>=0.0 && r<5373484.5 ){
-     p->iJD = (sqlite3_int64)(r*86400000.0 + 0.5);
-     p->validJD = 1;
-@@ -731,7 +733,16 @@ static int parseModifier(
-       ** show local time.
-       */
-       if( sqlite3_stricmp(z, "localtime")==0 && sqlite3NotPureFunc(pCtx) ){
--        rc = toLocaltime(p, pCtx);
-+        if( p->tzSet!=0 || p->tz==0 ) {
-+          rc = toLocaltime(p, pCtx);
-+          i64 iOrigJD = p->iJD;
-+          p->tzSet = 0;
-+          computeJD(p);
-+          p->tz = (p->iJD-iOrigJD)/60000;
-+          if( abs(p->tz)>= 900 ) p->tz = 0;
-+        } else {
-+          rc = 0;
-+        }
-       }
-       break;
-     }
-@@ -781,6 +792,7 @@ static int parseModifier(
-           p->validJD = 1;
-           p->tzSet = 1;
-         }
-+        p->tz = 0;
-         rc = SQLITE_OK;
-       }
- #endif

sqlite3/vtab.c

@@ -218,6 +218,7 @@ int sqlite3_vtab_config_go(sqlite3 *db, int op, int constraint) {
   return sqlite3_vtab_config(db, op, constraint);
 }
 
+static_assert(offsetof(struct sqlite3_vtab, zErrMsg) == 8, "Unexpected offset");
 static_assert(offsetof(struct go_module, base) == 4, "Unexpected offset");
 static_assert(offsetof(struct go_vtab, base) == 4, "Unexpected offset");
 static_assert(offsetof(struct go_cursor, base) == 4, "Unexpected offset");

util/osutil/open_windows.go

@@ -97,6 +97,10 @@ func syscallOpen(path string, mode int, perm uint32) (fd Handle, err error) {
 		// Necessary for opening directory handles.
 		attrs |= FILE_FLAG_BACKUP_SEMANTICS
 	}
+	if mode&O_SYNC != 0 {
+		const _FILE_FLAG_WRITE_THROUGH = 0x80000000
+		attrs |= _FILE_FLAG_WRITE_THROUGH
+	}
 	return CreateFile(pathp, access, sharemode, sa, createmode, attrs, 0)
 }
 

vfs/api.go

@@ -80,6 +80,16 @@ type FileOverwrite interface {
 	Overwrite() error
 }
 
+// FilePersistentWAL extends File to implement the
+// SQLITE_FCNTL_PERSIST_WAL file control opcode.
+//
+// https://sqlite.org/c3ref/c_fcntl_begin_atomic_write.html#sqlitefcntlpersistwal
+type FilePersistentWAL interface {
+	File
+	PersistentWAL() bool
+	SetPersistentWAL(bool)
+}
+
 // FilePowersafeOverwrite extends File to implement the
 // SQLITE_FCNTL_POWERSAFE_OVERWRITE file control opcode.
 //
@@ -90,7 +100,7 @@ type FilePowersafeOverwrite interface {
 	SetPowersafeOverwrite(bool)
 }
 
-// FilePowersafeOverwrite extends File to implement the
+// FileCommitPhaseTwo extends File to implement the
 // SQLITE_FCNTL_COMMIT_PHASETWO file control opcode.
 //
 // https://sqlite.org/c3ref/c_fcntl_begin_atomic_write.html#sqlitefcntlcommitphasetwo

vfs/clear.go

@@ -1,9 +0,0 @@
-//go:build !go1.21
-
-package vfs
-
-func clear(b []byte) {
-	for i := range b {
-		b[i] = 0
-	}
-}

vfs/file.go

@@ -126,9 +126,10 @@ func (vfsOS) OpenParams(name string, flags OpenFlag, params url.Values) (File, O
 type vfsFile struct {
 	*os.File
 	lock     LockLevel
-	psow     bool
-	syncDir  bool
 	readOnly bool
+	keepWAL  bool
+	syncDir  bool
+	psow     bool
 }
 
 var (
@@ -136,6 +137,7 @@ var (
 	_ FileLockState          = &vfsFile{}
 	_ FileHasMoved           = &vfsFile{}
 	_ FileSizeHint           = &vfsFile{}
+	_ FilePersistentWAL      = &vfsFile{}
 	_ FilePowersafeOverwrite = &vfsFile{}
 )
 
@@ -198,4 +200,6 @@ func (f *vfsFile) HasMoved() (bool, error) {
 
 func (f *vfsFile) LockState() LockLevel            { return f.lock }
 func (f *vfsFile) PowersafeOverwrite() bool        { return f.psow }
+func (f *vfsFile) PersistentWAL() bool             { return f.keepWAL }
 func (f *vfsFile) SetPowersafeOverwrite(psow bool) { f.psow = psow }
+func (f *vfsFile) SetPersistentWAL(keepWAL bool)   { f.keepWAL = keepWAL }

vfs/lock.go

@@ -65,14 +65,20 @@ func (f *vfsFile) Lock(lock LockLevel) error {
 		if f.lock <= LOCK_NONE || f.lock >= LOCK_EXCLUSIVE {
 			panic(util.AssertErr())
 		}
+		reserved := f.lock == LOCK_RESERVED
 		// A PENDING lock is needed before acquiring an EXCLUSIVE lock.
 		if f.lock < LOCK_PENDING {
-			if rc := osGetPendingLock(f.File); rc != _OK {
+			// If we're already RESERVED, we can block indefinitely,
+			// since only new readers may briefly hold the PENDING lock.
+			if rc := osGetPendingLock(f.File, reserved /* block */); rc != _OK {
 				return rc
 			}
 			f.lock = LOCK_PENDING
 		}
-		if rc := osGetExclusiveLock(f.File); rc != _OK {
+		// We already have PENDING, so we're just waiting for readers to leave.
+		// If we were RESERVED, we can wait for a little while, before invoking
+		// the busy handler; we will only do this once.
+		if rc := osGetExclusiveLock(f.File, reserved /* wait */); rc != _OK {
 			return rc
 		}
 		f.lock = LOCK_EXCLUSIVE

vfs/memdb/clear.go

@@ -1,10 +0,0 @@
-//go:build !go1.21
-
-package memdb
-
-func clear[T any](b []T) {
-	var zero T
-	for i := range b {
-		b[i] = zero
-	}
-}

vfs/os_bsd.go

@@ -19,28 +19,17 @@ func osUnlock(file *os.File, start, len int64) _ErrorCode {
 	return _OK
 }
 
-func osLock(file *os.File, how int, timeout time.Duration, def _ErrorCode) _ErrorCode {
-	before := time.Now()
-	var err error
-	for {
-		err = unix.Flock(int(file.Fd()), how)
-		if errno, _ := err.(unix.Errno); errno != unix.EAGAIN {
-			break
-		}
-		if timeout <= 0 || timeout < time.Since(before) {
-			break
-		}
-		time.Sleep(time.Millisecond)
-	}
+func osLock(file *os.File, how int, def _ErrorCode) _ErrorCode {
+	err := unix.Flock(int(file.Fd()), how)
 	return osLockErrorCode(err, def)
 }
 
-func osReadLock(file *os.File, start, len int64, timeout time.Duration) _ErrorCode {
-	return osLock(file, unix.LOCK_SH|unix.LOCK_NB, timeout, _IOERR_RDLOCK)
+func osReadLock(file *os.File, _ /*start*/, _ /*len*/ int64, _ /*timeout*/ time.Duration) _ErrorCode {
+	return osLock(file, unix.LOCK_SH|unix.LOCK_NB, _IOERR_RDLOCK)
 }
 
-func osWriteLock(file *os.File, start, len int64, timeout time.Duration) _ErrorCode {
-	return osLock(file, unix.LOCK_EX|unix.LOCK_NB, timeout, _IOERR_LOCK)
+func osWriteLock(file *os.File, _ /*start*/, _ /*len*/ int64, _ /*timeout*/ time.Duration) _ErrorCode {
+	return osLock(file, unix.LOCK_EX|unix.LOCK_NB, _IOERR_LOCK)
 }
 
 func osCheckLock(file *os.File, start, len int64) (bool, _ErrorCode) {

vfs/os_darwin.go

@@ -23,7 +23,7 @@ type flocktimeout_t struct {
 	timeout unix.Timespec
 }
 
-func osSync(file *os.File, fullsync, dataonly bool) error {
+func osSync(file *os.File, fullsync, _ /*dataonly*/ bool) error {
 	if fullsync {
 		return file.Sync()
 	}
@@ -75,9 +75,12 @@ func osLock(file *os.File, typ int16, start, len int64, timeout time.Duration, d
 		Len:   len,
 	}}
 	var err error
-	if timeout == 0 {
+	switch {
+	case timeout == 0:
 		err = unix.FcntlFlock(file.Fd(), _F_OFD_SETLK, &lock.fl)
-	} else {
+	case timeout < 0:
+		err = unix.FcntlFlock(file.Fd(), _F_OFD_SETLKW, &lock.fl)
+	default:
 		lock.timeout = unix.NsecToTimespec(int64(timeout / time.Nanosecond))
 		err = unix.FcntlFlock(file.Fd(), _F_OFD_SETLKWTIMEOUT, &lock.fl)
 	}

vfs/os_linux.go

@@ -8,7 +8,7 @@ import (
 	"golang.org/x/sys/unix"
 )
 
-func osSync(file *os.File, fullsync, dataonly bool) error {
+func osSync(file *os.File, _ /*fullsync*/, dataonly bool) error {
 	if dataonly {
 		_, _, err := unix.Syscall(unix.SYS_FDATASYNC, file.Fd(), 0, 0)
 		if err != 0 {

vfs/os_nolock.go

@@ -12,30 +12,30 @@ import "os"
 // [immutable]: https://sqlite.org/uri.html#uriimmutable
 const SupportsFileLocking = false
 
-func osGetSharedLock(file *os.File) _ErrorCode {
+func osGetSharedLock(_ *os.File) _ErrorCode {
 	return _IOERR_RDLOCK
 }
 
-func osGetReservedLock(file *os.File) _ErrorCode {
+func osGetReservedLock(_ *os.File) _ErrorCode {
 	return _IOERR_LOCK
 }
 
-func osGetPendingLock(file *os.File) _ErrorCode {
+func osGetPendingLock(_ *os.File, _ bool) _ErrorCode {
 	return _IOERR_LOCK
 }
 
-func osGetExclusiveLock(file *os.File) _ErrorCode {
+func osGetExclusiveLock(_ *os.File, _ bool) _ErrorCode {
 	return _IOERR_LOCK
 }
 
-func osDowngradeLock(file *os.File, state LockLevel) _ErrorCode {
+func osDowngradeLock(_ *os.File, _ LockLevel) _ErrorCode {
 	return _IOERR_RDLOCK
 }
 
-func osReleaseLock(file *os.File, _ LockLevel) _ErrorCode {
+func osReleaseLock(_ *os.File, _ LockLevel) _ErrorCode {
 	return _IOERR_UNLOCK
 }
 
-func osCheckReservedLock(file *os.File) (bool, _ErrorCode) {
+func osCheckReservedLock(_ *os.File) (bool, _ErrorCode) {
 	return false, _IOERR_CHECKRESERVEDLOCK
 }

vfs/os_ofd.go

@@ -27,17 +27,24 @@ func osLock(file *os.File, typ int16, start, len int64, timeout time.Duration, d
 		Start: start,
 		Len:   len,
 	}
-	before := time.Now()
 	var err error
-	for {
+	switch {
+	case timeout == 0:
 		err = unix.FcntlFlock(file.Fd(), unix.F_OFD_SETLK, &lock)
-		if errno, _ := err.(unix.Errno); errno != unix.EAGAIN {
-			break
+	case timeout < 0:
+		err = unix.FcntlFlock(file.Fd(), unix.F_OFD_SETLKW, &lock)
+	default:
+		before := time.Now()
+		for {
+			err = unix.FcntlFlock(file.Fd(), unix.F_OFD_SETLK, &lock)
+			if errno, _ := err.(unix.Errno); errno != unix.EAGAIN {
+				break
+			}
+			if timeout <= 0 || timeout < time.Since(before) {
+				break
+			}
+			osSleep(time.Millisecond)
 		}
-		if timeout <= 0 || timeout < time.Since(before) {
-			break
-		}
-		time.Sleep(time.Millisecond)
 	}
 	return osLockErrorCode(err, def)
 }

vfs/os_std_sleep.go

@@ -0,0 +1,9 @@
+//go:build !windows || sqlite3_nosys
+
+package vfs
+
+import "time"
+
+func osSleep(d time.Duration) {
+	time.Sleep(d)
+}

vfs/os_std_sync.go

@@ -4,6 +4,6 @@ package vfs
 
 import "os"
 
-func osSync(file *os.File, fullsync, dataonly bool) error {
+func osSync(file *os.File, _ /*fullsync*/, _ /*dataonly*/ bool) error {
 	return file.Sync()
 }

vfs/os_unix_lock.go

@@ -31,14 +31,22 @@ func osGetReservedLock(file *os.File) _ErrorCode {
 	return osWriteLock(file, _RESERVED_BYTE, 1, 0)
 }
 
-func osGetPendingLock(file *os.File) _ErrorCode {
+func osGetPendingLock(file *os.File, block bool) _ErrorCode {
+	var timeout time.Duration
+	if block {
+		timeout = -1
+	}
 	// Acquire the PENDING lock.
-	return osWriteLock(file, _PENDING_BYTE, 1, 0)
+	return osWriteLock(file, _PENDING_BYTE, 1, timeout)
 }
 
-func osGetExclusiveLock(file *os.File) _ErrorCode {
+func osGetExclusiveLock(file *os.File, wait bool) _ErrorCode {
+	var timeout time.Duration
+	if wait {
+		timeout = time.Millisecond
+	}
 	// Acquire the EXCLUSIVE lock.
-	return osWriteLock(file, _SHARED_FIRST, _SHARED_SIZE, time.Millisecond)
+	return osWriteLock(file, _SHARED_FIRST, _SHARED_SIZE, timeout)
 }
 
 func osDowngradeLock(file *os.File, state LockLevel) _ErrorCode {

vfs/os_windows.go

@@ -36,17 +36,27 @@ func osGetReservedLock(file *os.File) _ErrorCode {
 	return osWriteLock(file, _RESERVED_BYTE, 1, 0)
 }
 
-func osGetPendingLock(file *os.File) _ErrorCode {
+func osGetPendingLock(file *os.File, block bool) _ErrorCode {
+	var timeout time.Duration
+	if block {
+		timeout = -1
+	}
+
 	// Acquire the PENDING lock.
-	return osWriteLock(file, _PENDING_BYTE, 1, 0)
+	return osWriteLock(file, _PENDING_BYTE, 1, timeout)
 }
 
-func osGetExclusiveLock(file *os.File) _ErrorCode {
+func osGetExclusiveLock(file *os.File, wait bool) _ErrorCode {
+	var timeout time.Duration
+	if wait {
+		timeout = time.Millisecond
+	}
+
 	// Release the SHARED lock.
 	osUnlock(file, _SHARED_FIRST, _SHARED_SIZE)
 
 	// Acquire the EXCLUSIVE lock.
-	rc := osWriteLock(file, _SHARED_FIRST, _SHARED_SIZE, time.Millisecond)
+	rc := osWriteLock(file, _SHARED_FIRST, _SHARED_SIZE, timeout)
 
 	if rc != _OK {
 		// Reacquire the SHARED lock.
@@ -110,44 +120,43 @@ func osUnlock(file *os.File, start, len uint32) _ErrorCode {
 }
 
 func osLock(file *os.File, flags, start, len uint32, timeout time.Duration, def _ErrorCode) _ErrorCode {
-	before := time.Now()
 	var err error
-	for {
-		err = windows.LockFileEx(windows.Handle(file.Fd()), flags,
-			0, len, 0, &windows.Overlapped{Offset: start})
-		if errno, _ := err.(windows.Errno); errno != windows.ERROR_LOCK_VIOLATION {
-			break
-		}
-		if timeout <= 0 || timeout < time.Since(before) {
-			break
-		}
-		if err := windows.TimeBeginPeriod(1); err != nil {
-			break
-		}
-		time.Sleep(time.Millisecond)
-		if err := windows.TimeEndPeriod(1); err != nil {
-			break
+	switch {
+	case timeout == 0:
+		err = osLockEx(file, flags|windows.LOCKFILE_FAIL_IMMEDIATELY, start, len)
+	case timeout < 0:
+		err = osLockEx(file, flags, start, len)
+	default:
+		before := time.Now()
+		for {
+			err = osLockEx(file, flags|windows.LOCKFILE_FAIL_IMMEDIATELY, start, len)
+			if errno, _ := err.(windows.Errno); errno != windows.ERROR_LOCK_VIOLATION {
+				break
+			}
+			if timeout <= 0 || timeout < time.Since(before) {
+				break
+			}
+			osSleep(time.Millisecond)
 		}
 	}
 	return osLockErrorCode(err, def)
 }
 
+func osLockEx(file *os.File, flags, start, len uint32) error {
+	return windows.LockFileEx(windows.Handle(file.Fd()), flags,
+		0, len, 0, &windows.Overlapped{Offset: start})
+}
+
 func osReadLock(file *os.File, start, len uint32, timeout time.Duration) _ErrorCode {
-	return osLock(file,
-		windows.LOCKFILE_FAIL_IMMEDIATELY,
-		start, len, timeout, _IOERR_RDLOCK)
+	return osLock(file, 0, start, len, timeout, _IOERR_RDLOCK)
 }
 
 func osWriteLock(file *os.File, start, len uint32, timeout time.Duration) _ErrorCode {
-	return osLock(file,
-		windows.LOCKFILE_FAIL_IMMEDIATELY|windows.LOCKFILE_EXCLUSIVE_LOCK,
-		start, len, timeout, _IOERR_LOCK)
+	return osLock(file, windows.LOCKFILE_EXCLUSIVE_LOCK, start, len, timeout, _IOERR_LOCK)
 }
 
 func osCheckLock(file *os.File, start, len uint32) (bool, _ErrorCode) {
-	rc := osLock(file,
-		windows.LOCKFILE_FAIL_IMMEDIATELY,
-		start, len, 0, _IOERR_CHECKRESERVEDLOCK)
+	rc := osLock(file, 0, start, len, 0, _IOERR_CHECKRESERVEDLOCK)
 	if rc == _BUSY {
 		return true, _OK
 	}
@@ -173,3 +182,16 @@ func osLockErrorCode(err error, def _ErrorCode) _ErrorCode {
 	}
 	return def
 }
+
+func osSleep(d time.Duration) {
+	if d > 0 {
+		period := max(1, d/(5*time.Millisecond))
+		if period < 16 {
+			windows.TimeBeginPeriod(uint32(period))
+		}
+		time.Sleep(d)
+		if period < 16 {
+			windows.TimeEndPeriod(uint32(period))
+		}
+	}
+}

vfs/tests/mptest/mptest_test.go

@@ -49,6 +49,9 @@ func TestMain(m *testing.M) {
 		panic(err)
 	}
 
+	if !strings.HasPrefix(compressed, "BZh") {
+		panic("Please use Git LFS to clone this repo: https://git-lfs.com/")
+	}
 	binary, err := io.ReadAll(bzip2.NewReader(strings.NewReader(compressed)))
 	if err != nil {
 		panic(err)

vfs/tests/mptest/testdata/build.sh

@@ -4,7 +4,7 @@ set -euo pipefail
 cd -P -- "$(dirname -- "$0")"
 
 ROOT=../../../../
-BINARYEN="$ROOT/tools/binaryen-version_116/bin"
+BINARYEN="$ROOT/tools/binaryen-version_117/bin"
 WASI_SDK="$ROOT/tools/wasi-sdk-21.0/bin"
 
 "$WASI_SDK/clang" --target=wasm32-wasi -std=c17 -flto -g0 -O2 \

vfs/tests/mptest/testdata/mptest.wasm.bz2

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1c012cb70dbded801b5241755f2e8c09f6baeda039056f5556b01a3de41e6a6b
-size 520334
+oid sha256:b5f4778b49a6b99a1be11db5cb07e3c5b52f91a932a97e33c895f52c6f54bf57
+size 469149

vfs/tests/speedtest1/speedtest1_test.go

@@ -46,6 +46,9 @@ func TestMain(m *testing.M) {
 		panic(err)
 	}
 
+	if !strings.HasPrefix(compressed, "BZh") {
+		panic("Please use Git LFS to clone this repo: https://git-lfs.com/")
+	}
 	binary, err := io.ReadAll(bzip2.NewReader(strings.NewReader(compressed)))
 	if err != nil {
 		panic(err)

vfs/tests/speedtest1/testdata/build.sh

@@ -4,7 +4,7 @@ set -euo pipefail
 cd -P -- "$(dirname -- "$0")"
 
 ROOT=../../../../
-BINARYEN="$ROOT/tools/binaryen-version_116/bin"
+BINARYEN="$ROOT/tools/binaryen-version_117/bin"
 WASI_SDK="$ROOT/tools/wasi-sdk-21.0/bin"
 
 "$WASI_SDK/clang" --target=wasm32-wasi -std=c17 -flto -g0 -O2 \

vfs/tests/speedtest1/testdata/speedtest1.wasm.bz2

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ed1b7711b1246218aaa967ecdc8bf655708b90752ea6b3dd12a5ee307c032416
-size 534713
+oid sha256:06882576fdea2c8e164dd2d97dce394dc825dca3cee30c9efc9601b84de92865
+size 483191

vfs/vfs.go

@@ -79,7 +79,7 @@ func vfsRandomness(ctx context.Context, mod api.Module, pVfs, nByte, zByte uint3
 }
 
 func vfsSleep(ctx context.Context, mod api.Module, pVfs, nMicro uint32) _ErrorCode {
-	time.Sleep(time.Duration(nMicro) * time.Microsecond)
+	osSleep(time.Duration(nMicro) * time.Microsecond)
 	return _OK
 }
 
@@ -257,19 +257,26 @@ func vfsFileControl(ctx context.Context, mod api.Module, pFile uint32, op _Fcntl
 			return _OK
 		}
 
+	case _FCNTL_PERSIST_WAL:
+		if file, ok := file.(FilePersistentWAL); ok {
+			if i := util.ReadUint32(mod, pArg); int32(i) >= 0 {
+				file.SetPersistentWAL(i != 0)
+			} else if file.PersistentWAL() {
+				util.WriteUint32(mod, pArg, 1)
+			} else {
+				util.WriteUint32(mod, pArg, 0)
+			}
+			return _OK
+		}
+
 	case _FCNTL_POWERSAFE_OVERWRITE:
 		if file, ok := file.(FilePowersafeOverwrite); ok {
-			switch util.ReadUint32(mod, pArg) {
-			case 0:
-				file.SetPowersafeOverwrite(false)
-			case 1:
-				file.SetPowersafeOverwrite(true)
-			default:
-				if file.PowersafeOverwrite() {
-					util.WriteUint32(mod, pArg, 1)
-				} else {
-					util.WriteUint32(mod, pArg, 0)
-				}
+			if i := util.ReadUint32(mod, pArg); int32(i) >= 0 {
+				file.SetPowersafeOverwrite(i != 0)
+			} else if file.PowersafeOverwrite() {
+				util.WriteUint32(mod, pArg, 1)
+			} else {
+				util.WriteUint32(mod, pArg, 0)
 			}
 			return _OK
 		}
@@ -284,12 +291,10 @@ func vfsFileControl(ctx context.Context, mod api.Module, pFile uint32, op _Fcntl
 	case _FCNTL_HAS_MOVED:
 		if file, ok := file.(FileHasMoved); ok {
 			moved, err := file.HasMoved()
-
 			var res uint32
 			if moved {
 				res = 1
 			}
-
 			util.WriteUint32(mod, pArg, res)
 			return vfsErrorCode(err, _IOERR_FSTAT)
 		}
@@ -326,6 +331,8 @@ func vfsFileControl(ctx context.Context, mod api.Module, pFile uint32, op _Fcntl
 	// Consider also implementing these opcodes (in use by SQLite):
 	//  _FCNTL_BUSYHANDLER
 	//  _FCNTL_CHUNK_SIZE
+	//  _FCNTL_CKPT_DONE
+	//  _FCNTL_CKPT_START
 	//  _FCNTL_PRAGMA
 	//  _FCNTL_SYNC
 	return _NOTFOUND

vtab.go

@@ -628,13 +628,14 @@ const (
 )
 
 func vtabError(ctx context.Context, mod api.Module, ptr, kind uint32, err error) uint32 {
+	const zErrMsgOffset = 8
 	msg, code := errorCode(err, ERROR)
 	if msg != "" && ptr != 0 {
 		switch kind {
 		case _VTAB_ERROR:
-			ptr = ptr + 8 // zErrMsg
+			ptr = ptr + zErrMsgOffset // zErrMsg
 		case _CURSOR_ERROR:
-			ptr = util.ReadUint32(mod, ptr) + 8 // pVTab->zErrMsg
+			ptr = util.ReadUint32(mod, ptr) + zErrMsgOffset // pVTab->zErrMsg
 		}
 		db := ctx.Value(connKey{}).(*Conn)
 		if ptr := util.ReadUint32(mod, ptr); ptr != 0 {