SQLite 3.50.0.

I find the example SQL queries a bit difficult to read at the callsite with the magic numbers and ? placeholders. I think sql.Named makes it more obvious to the reader what the different parts of the SQL query represent.

.github/workflows/libc.yml

@@ -0,0 +1,23 @@
+name: Benchmark libc
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        os: [ubuntu-24.04, ubuntu-24.04-arm, macos-13, macos-15]
+    runs-on: ${{ matrix.os }}
+
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-go@v5
+      with: { go-version: stable }
+
+    - name: Benchmark
+      shell: bash
+      run: sqlite3/libc/benchmark.sh

.github/workflows/repro.sh

@@ -1,28 +1,9 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-if [[ "$OSTYPE" == "linux"* ]]; then
-  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-25/wasi-sdk-25.0-x86_64-linux.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_123/binaryen-version_123-x86_64-linux.tar.gz"
-elif [[ "$OSTYPE" == "darwin"* ]]; then
-  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-25/wasi-sdk-25.0-arm64-macos.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_123/binaryen-version_123-arm64-macos.tar.gz"
-elif [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" ]]; then
-  WASI_SDK="https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-25/wasi-sdk-25.0-x86_64-windows.tar.gz"
-  BINARYEN="https://github.com/WebAssembly/binaryen/releases/download/version_123/binaryen-version_123-x86_64-windows.tar.gz"
-fi
-
-# Download tools
-mkdir -p tools/
-[ -d "tools/wasi-sdk" ] || curl -#L "$WASI_SDK" | tar xzC tools &
-[ -d "tools/binaryen" ] || curl -#L "$BINARYEN" | tar xzC tools &
-wait
-
-[ -d "tools/wasi-sdk" ] || mv "tools/wasi-sdk"* "tools/wasi-sdk"
-[ -d "tools/binaryen" ] || mv "tools/binaryen"* "tools/binaryen"
-
 # Download and build SQLite
 sqlite3/download.sh
+sqlite3/tools.sh
 embed/build.sh
 embed/bcw2/build.sh
 

.github/workflows/test.yml

@@ -17,12 +17,17 @@ on:
       - '**.yml'
   workflow_dispatch:
 
+permissions:
+  contents: read
+
 jobs:
   test:
     strategy:
       matrix:
         os: [macos-latest, ubuntu-latest, windows-latest]
     runs-on: ${{ matrix.os }}
+    permissions:
+      contents: write
 
     steps:
     - uses: actions/checkout@v4
@@ -107,7 +112,7 @@ jobs:
             version: '10.1'
             flags: '-test.v -test.short'
           - name: openbsd
-            version: '7.6'
+            version: '7.7'
             flags: '-test.v -test.short'
     runs-on: ubuntu-latest
     needs: test
@@ -123,7 +128,7 @@ jobs:
       run: .github/workflows/build-test.sh
 
     - name: Test
-      uses: cross-platform-actions/action@v0.27.0
+      uses: cross-platform-actions/action@v0.28.0
       with:
         operating_system: ${{ matrix.os.name }}
         architecture: ${{ matrix.os.arch }}

README.md

@@ -30,10 +30,10 @@ db.QueryRow(`SELECT sqlite_version()`).Scan(&version)
 
 - [`github.com/ncruces/go-sqlite3`](https://pkg.go.dev/github.com/ncruces/go-sqlite3)
   wraps the [C SQLite API](https://sqlite.org/cintro.html)
-  ([example usage](https://pkg.go.dev/github.com/ncruces/go-sqlite3#example-package)).
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3#example-package)).
 - [`github.com/ncruces/go-sqlite3/driver`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver)
   provides a [`database/sql`](https://pkg.go.dev/database/sql) driver
-  ([example usage](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#example-package)).
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#example-package)).
 - [`github.com/ncruces/go-sqlite3/embed`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/embed)
   embeds a build of SQLite into your application.
 - [`github.com/ncruces/go-sqlite3/vfs`](https://pkg.go.dev/github.com/ncruces/go-sqlite3/vfs)
@@ -44,12 +44,19 @@ db.QueryRow(`SELECT sqlite_version()`).Scan(&version)
 ### Advanced features
 
 - [incremental BLOB I/O](https://sqlite.org/c3ref/blob_open.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/blobio#example-package))
 - [nested transactions](https://sqlite.org/lang_savepoint.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#example-Savepoint))
 - [custom functions](https://sqlite.org/c3ref/create_function.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3#example-Conn.CreateFunction))
 - [virtual tables](https://sqlite.org/vtab.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3#example-CreateModule))
 - [custom VFSes](https://sqlite.org/vfs.html)
+  ([examples](vfs/README.md#custom-vfses))
 - [online backup](https://sqlite.org/backup.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#Conn))
 - [JSON support](https://sqlite.org/json1.html)
+  ([example](https://pkg.go.dev/github.com/ncruces/go-sqlite3/driver#example-package-Json))
 - [math functions](https://sqlite.org/lang_mathfunc.html)
 - [full-text search](https://sqlite.org/fts5.html)
 - [geospatial search](https://sqlite.org/geopoly.html)
@@ -57,7 +64,6 @@ db.QueryRow(`SELECT sqlite_version()`).Scan(&version)
 - [statistics functions](https://pkg.go.dev/github.com/ncruces/go-sqlite3/ext/stats)
 - [encryption at rest](vfs/adiantum/README.md)
 - [many extensions](ext/README.md)
-- [custom VFSes](vfs/README.md#custom-vfses)
 - [and more…](embed/README.md)
 
 ### Caveats
@@ -77,10 +83,19 @@ It also benefits greatly from [SQLite's](https://sqlite.org/testing.html) and
 [wazero's](https://tetrate.io/blog/introducing-wazero-from-tetrate/#:~:text=Rock%2Dsolid%20test%20approach)
 thorough testing.
 
-Every commit is [tested](https://github.com/ncruces/go-sqlite3/wiki/Support-matrix) on
-Linux (amd64/arm64/386/riscv64/ppc64le/s390x), macOS (arm64/amd64),
-Windows (amd64), FreeBSD (amd64/arm64), OpenBSD (amd64), NetBSD (amd64/arm64),
-DragonFly BSD (amd64), illumos (amd64), and Solaris (amd64).
+Every commit is tested on:
+* Linux: amd64, arm64, 386, riscv64, ppc64le, s390x
+* macOS: amd64, arm64
+* Windows: amd64
+* BSD:
+  * FreeBSD: amd64, arm64
+  * OpenBSD: amd64
+  * NetBSD: amd64, arm64
+  * DragonFly BSD: amd64
+* illumos: amd64
+* Solaris: amd64
+
+Certain operating system and CPU combinations have some limitations. See the [support matrix](https://github.com/ncruces/go-sqlite3/wiki/Support-matrix) for a complete overview.
 
 The Go VFS is tested by running SQLite's
 [mptest](https://github.com/sqlite/sqlite/blob/master/mptest/mptest.c).
@@ -118,4 +133,4 @@ and features we're working on, planning to work on, or asking for help with.
 - [`modernc.org/sqlite`](https://pkg.go.dev/modernc.org/sqlite)
 - [`crawshaw.io/sqlite`](https://pkg.go.dev/crawshaw.io/sqlite)
 - [`github.com/mattn/go-sqlite3`](https://pkg.go.dev/github.com/mattn/go-sqlite3)
-- [`github.com/zombiezen/go-sqlite`](https://pkg.go.dev/github.com/zombiezen/go-sqlite)
+- [`github.com/zombiezen/go-sqlite`](https://pkg.go.dev/github.com/zombiezen/go-sqlite)

config.go

@@ -109,7 +109,7 @@ func (c *Conn) FileControl(schema string, op FcntlOpcode, arg ...any) (any, erro
 	default:
 		return nil, MISUSE
 
-	case FCNTL_RESET_CACHE:
+	case FCNTL_RESET_CACHE, FCNTL_NULL_IO:
 		rc = res_t(c.call("sqlite3_file_control",
 			stk_t(c.handle), stk_t(schemaPtr),
 			stk_t(op), 0))

const.go

@@ -280,6 +280,7 @@ const (
 	FCNTL_DATA_VERSION        FcntlOpcode = 35
 	FCNTL_RESERVE_BYTES       FcntlOpcode = 38
 	FCNTL_RESET_CACHE         FcntlOpcode = 42
+	FCNTL_NULL_IO             FcntlOpcode = 43
 )
 
 // LimitCategory are the available run-time limit categories.

context.go

@@ -177,12 +177,15 @@ func (ctx Context) ResultPointer(ptr any) {
 //
 // https://sqlite.org/c3ref/result_blob.html
 func (ctx Context) ResultJSON(value any) {
-	data, err := json.Marshal(value)
+	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
 	}
-	ctx.ResultRawText(data)
 }
 
 // ResultValue sets the result of the function to a copy of [Value].

driver/driver.go

@@ -241,8 +241,9 @@ func (n *connector) Connect(ctx context.Context) (ret driver.Conn, err error) {
 		}
 	}()
 
-	old := c.Conn.SetInterrupt(ctx)
-	defer c.Conn.SetInterrupt(old)
+	if old := c.Conn.SetInterrupt(ctx); old != ctx {
+		defer c.Conn.SetInterrupt(old)
+	}
 
 	if !n.pragmas {
 		err = c.Conn.BusyTimeout(time.Minute)
@@ -362,8 +363,9 @@ func (c *conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, e
 		c.txReset = `; PRAGMA query_only=` + string(c.readOnly)
 	}
 
-	old := c.Conn.SetInterrupt(ctx)
-	defer c.Conn.SetInterrupt(old)
+	if old := c.Conn.SetInterrupt(ctx); old != ctx {
+		defer c.Conn.SetInterrupt(old)
+	}
 
 	err := c.Conn.Exec(txBegin)
 	if err != nil {
@@ -382,8 +384,10 @@ func (c *conn) Commit() error {
 
 func (c *conn) Rollback() error {
 	// ROLLBACK even if interrupted.
-	old := c.Conn.SetInterrupt(context.Background())
-	defer c.Conn.SetInterrupt(old)
+	ctx := context.Background()
+	if old := c.Conn.SetInterrupt(ctx); old != ctx {
+		defer c.Conn.SetInterrupt(old)
+	}
 	return c.Conn.Exec(`ROLLBACK` + c.txReset)
 }
 
@@ -393,8 +397,9 @@ func (c *conn) Prepare(query string) (driver.Stmt, error) {
 }
 
 func (c *conn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) {
-	old := c.Conn.SetInterrupt(ctx)
-	defer c.Conn.SetInterrupt(old)
+	if old := c.Conn.SetInterrupt(ctx); old != ctx {
+		defer c.Conn.SetInterrupt(old)
+	}
 
 	s, tail, err := c.Conn.Prepare(query)
 	if err != nil {
@@ -419,8 +424,9 @@ func (c *conn) ExecContext(ctx context.Context, query string, args []driver.Name
 		return resultRowsAffected(0), nil
 	}
 
-	old := c.Conn.SetInterrupt(ctx)
-	defer c.Conn.SetInterrupt(old)
+	if old := c.Conn.SetInterrupt(ctx); old != ctx {
+		defer c.Conn.SetInterrupt(old)
+	}
 
 	err := c.Conn.Exec(query)
 	if err != nil {
@@ -483,8 +489,10 @@ func (s *stmt) ExecContext(ctx context.Context, args []driver.NamedValue) (drive
 		return nil, err
 	}
 
-	old := s.Stmt.Conn().SetInterrupt(ctx)
-	defer s.Stmt.Conn().SetInterrupt(old)
+	c := s.Stmt.Conn()
+	if old := c.SetInterrupt(ctx); old != ctx {
+		defer c.SetInterrupt(old)
+	}
 
 	err = errors.Join(
 		s.Stmt.Exec(),
@@ -493,7 +501,7 @@ func (s *stmt) ExecContext(ctx context.Context, args []driver.NamedValue) (drive
 		return nil, err
 	}
 
-	return newResult(s.Stmt.Conn()), nil
+	return newResult(c), nil
 }
 
 func (s *stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
@@ -678,13 +686,14 @@ func (r *rows) scanType(index int) scantype {
 
 func (r *rows) loadColumnMetadata() {
 	if r.nulls == nil {
+		c := r.Stmt.Conn()
 		count := r.Stmt.ColumnCount()
 		nulls := make([]bool, count)
 		types := make([]string, count)
 		scans := make([]scantype, count)
 		for i := range nulls {
 			if col := r.Stmt.ColumnOriginName(i); col != "" {
-				types[i], _, nulls[i], _, _, _ = r.Stmt.Conn().TableColumnMetadata(
+				types[i], _, nulls[i], _, _, _ = c.TableColumnMetadata(
 					r.Stmt.ColumnDatabaseName(i),
 					r.Stmt.ColumnTableName(i),
 					col)
@@ -762,8 +771,10 @@ func (r *rows) ColumnTypeScanType(index int) (typ reflect.Type) {
 }
 
 func (r *rows) Next(dest []driver.Value) error {
-	old := r.Stmt.Conn().SetInterrupt(r.ctx)
-	defer r.Stmt.Conn().SetInterrupt(old)
+	c := r.Stmt.Conn()
+	if old := c.SetInterrupt(r.ctx); old != r.ctx {
+		defer c.SetInterrupt(old)
+	}
 
 	if !r.Stmt.Step() {
 		if err := r.Stmt.Err(); err != nil {

driver/driver_test.go

@@ -248,8 +248,10 @@ func Test_nested_context(t *testing.T) {
 	want(inner, 0)
 	cancel()
 
-	if inner.Next() || !errors.Is(inner.Err(), sqlite3.INTERRUPT) {
-		t.Fatal(inner.Err())
+	var terr interface{ Temporary() bool }
+	if inner.Next() || !errors.Is(inner.Err(), context.Canceled) &&
+		(!errors.As(inner.Err(), &terr) || !terr.Temporary()) {
+		t.Fatalf("got %v, want cancellation", inner.Err())
 	}
 
 	want(outer, 1)

embed/README.md

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

embed/bcw2/build.sh

@@ -13,11 +13,10 @@ mkdir -p build/ext/
 cp "$ROOT"/sqlite3/*.[ch] build/
 cp "$ROOT"/sqlite3/*.patch build/
 
-# https://sqlite.org/src/info/c09656c62155a6e8
-curl -# https://sqlite.org/src/tarball/sqlite.tar.gz?r=c09656c6 | tar xz
+# https://sqlite.org/src/info/54b8888080d99a87
+curl -# https://sqlite.org/src/tarball/sqlite.tar.gz?r=54b8888080 | tar xz
 
 cd sqlite
-cat ../repro.patch | patch -p0 --no-backup-if-mismatch
 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
@@ -44,12 +43,12 @@ cd ~-
 
 "$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -g0 -O2 \
 	-Wall -Wextra -Wno-unused-parameter -Wno-unused-function \
-	-o bcw2.wasm "build/main.c" \
-	-I"build" \
+	-o bcw2.wasm build/main.c \
+	-I"$ROOT/sqlite3/libc" -I"build" \
 	-mexec-model=reactor \
-	-msimd128 -mmutable-globals -mmultivalue \
-	-mbulk-memory -mreference-types \
-	-mnontrapping-fptoint -msign-ext \
+	-mmutable-globals -mnontrapping-fptoint \
+	-msimd128 -mbulk-memory -msign-ext \
+	-mreference-types -mmultivalue \
 	-fno-stack-protector -fno-stack-clash-protection \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
@@ -61,7 +60,7 @@ cd ~-
 
 "$BINARYEN/wasm-ctor-eval" -g -c _initialize bcw2.wasm -o bcw2.tmp
 "$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
-	bcw2.tmp -o bcw2.wasm \
-	--enable-simd --enable-mutable-globals --enable-multivalue \
-	--enable-bulk-memory --enable-reference-types \
-	--enable-nontrapping-float-to-int --enable-sign-ext
+	bcw2.tmp -o bcw2.wasm --low-memory-unused \
+	--enable-mutable-globals --enable-nontrapping-float-to-int \
+	--enable-simd --enable-bulk-memory --enable-sign-ext \
+	--enable-reference-types --enable-multivalue

embed/bcw2/go.mod

@@ -4,11 +4,11 @@ go 1.23.0
 
 toolchain go1.24.0
 
-require github.com/ncruces/go-sqlite3 v0.24.0
+require github.com/ncruces/go-sqlite3 v0.25.0
 
 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.30.0 // indirect
+	golang.org/x/sys v0.32.0 // indirect
 )

embed/bcw2/go.sum

@@ -1,12 +1,12 @@
-github.com/ncruces/go-sqlite3 v0.24.0 h1:Z4jfmzu2NCd4SmyFwLT2OmF3EnTZbqwATvdiuNHNhLA=
-github.com/ncruces/go-sqlite3 v0.24.0/go.mod h1:/Vs8ACZHjJ1SA6E9RZUn3EyB1OP3nDQ4z/ar+0fplTQ=
+github.com/ncruces/go-sqlite3 v0.25.0 h1:trugKUs98Zwy9KwRr/EUxZHL92LYt7UqcKqAfpGpK+I=
+github.com/ncruces/go-sqlite3 v0.25.0/go.mod h1:n6Z7036yFilJx04yV0mi5JWaF66rUmXn1It9Ux8dx68=
 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.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
-golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
-golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
+golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
+golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
+golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=

embed/bcw2/repro.patch

@@ -1,23 +0,0 @@
-# https://sqlite.org/src/vpatch?from=67809715977a5bad&to=3f57584710d61174
---- tool/mkpragmatab.tcl
-+++ tool/mkpragmatab.tcl
-@@ -526,14 +526,17 @@
-   puts $fd [format {#define PragFlg_%-10s 0x%02x /* %s */} \
-              $f $fv $flagMeaning($f)]
-   set fv [expr {$fv*2}]
- }
- 
--# Sort the column lists so that longer column lists occur first
-+# Sort the column lists so that longer column lists occur first.
-+# In the event of a tie, sort column lists lexicographically.
- #
- proc colscmp {a b} {
--  return [expr {[llength $b] - [llength $a]}]
-+  set rc [expr {[llength $b] - [llength $a]}]
-+  if {$rc} {return $rc}
-+  return [string compare $a $b]
- }
- set cols_list [lsort -command colscmp $cols_list]
- 
- # Generate the array of column names used by pragmas that act like
- # queries.

embed/build.sh

@@ -12,11 +12,11 @@ trap 'rm -f sqlite3.tmp' EXIT
 "$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -g0 -O2 \
 	-Wall -Wextra -Wno-unused-parameter -Wno-unused-function \
 	-o sqlite3.wasm "$ROOT/sqlite3/main.c" \
-	-I"$ROOT/sqlite3" \
+	-I"$ROOT/sqlite3/libc" -I"$ROOT/sqlite3" \
 	-mexec-model=reactor \
-	-msimd128 -mmutable-globals -mmultivalue \
-	-mbulk-memory -mreference-types \
-	-mnontrapping-fptoint -msign-ext \
+	-mmutable-globals -mnontrapping-fptoint \
+	-msimd128 -mbulk-memory -msign-ext \
+	-mreference-types -mmultivalue \
 	-fno-stack-protector -fno-stack-clash-protection \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
@@ -27,7 +27,7 @@ trap 'rm -f sqlite3.tmp' EXIT
 
 "$BINARYEN/wasm-ctor-eval" -g -c _initialize sqlite3.wasm -o sqlite3.tmp
 "$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
-	sqlite3.tmp -o sqlite3.wasm \
-	--enable-simd --enable-mutable-globals --enable-multivalue \
-	--enable-bulk-memory --enable-reference-types \
-	--enable-nontrapping-float-to-int --enable-sign-ext
+	sqlite3.tmp -o sqlite3.wasm --low-memory-unused \
+	--enable-mutable-globals --enable-nontrapping-float-to-int \
+	--enable-simd --enable-bulk-memory --enable-sign-ext \
+	--enable-reference-types --enable-multivalue

embed/exports.txt

@@ -66,6 +66,7 @@ sqlite3_errmsg
 sqlite3_error_offset
 sqlite3_errstr
 sqlite3_exec
+sqlite3_exec_go
 sqlite3_expanded_sql
 sqlite3_file_control
 sqlite3_filename_database

embed/init_test.go

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

error.go

@@ -75,7 +75,7 @@ func (e *Error) As(err any) bool {
 
 // Temporary returns true for [BUSY] errors.
 func (e *Error) Temporary() bool {
-	return e.Code() == BUSY
+	return e.Code() == BUSY || e.Code() == INTERRUPT
 }
 
 // Timeout returns true for [BUSY_TIMEOUT] errors.

ext/blobio/blob_test.go

@@ -1,6 +1,7 @@
 package blobio_test
 
 import (
+	"database/sql"
 	"io"
 	"log"
 	"os"
@@ -34,7 +35,8 @@ func Example() {
 	const message = "Hello BLOB!"
 
 	// Create the BLOB.
-	r, err := db.Exec(`INSERT INTO test VALUES (?)`, sqlite3.ZeroBlob(len(message)))
+	r, err := db.Exec(`INSERT INTO test VALUES (:data)`,
+		sql.Named("data", sqlite3.ZeroBlob(len(message))))
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -45,15 +47,19 @@ func Example() {
 	}
 
 	// Write the BLOB.
-	_, err = db.Exec(`SELECT writeblob('main', 'test', 'col', ?, 0, ?)`,
-		id, message)
+	_, err = db.Exec(`SELECT writeblob('main', 'test', 'col', :rowid, :offset, :message)`,
+		sql.Named("rowid", id),
+		sql.Named("offset", 0),
+		sql.Named("message", message))
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	// Read the BLOB.
-	_, err = db.Exec(`SELECT readblob('main', 'test', 'col', ?, 0, ?)`,
-		id, sqlite3.Pointer(os.Stdout))
+	_, err = db.Exec(`SELECT readblob('main', 'test', 'col', :rowid, :offset, :writer)`,
+		sql.Named("rowid", id),
+		sql.Named("offset", 0),
+		sql.Named("writer", sqlite3.Pointer(os.Stdout)))
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -64,7 +70,7 @@ func Example() {
 func TestMain(m *testing.M) {
 	sqlite3.AutoExtension(blobio.Register)
 	sqlite3.AutoExtension(array.Register)
-	m.Run()
+	os.Exit(m.Run())
 }
 
 func Test_readblob(t *testing.T) {

ext/bloom/bloom_test.go

@@ -14,7 +14,7 @@ import (
 
 func TestMain(m *testing.M) {
 	sqlite3.AutoExtension(bloom.Register)
-	m.Run()
+	os.Exit(m.Run())
 }
 
 func TestRegister(t *testing.T) {

ext/closure/closure_test.go

@@ -4,6 +4,7 @@ import (
 	_ "embed"
 	"fmt"
 	"log"
+	"os"
 	"testing"
 
 	"github.com/ncruces/go-sqlite3"
@@ -14,7 +15,7 @@ import (
 
 func TestMain(m *testing.M) {
 	sqlite3.AutoExtension(closure.Register)
-	m.Run()
+	os.Exit(m.Run())
 }
 
 func Example() {

ext/csv/csv_test.go

@@ -3,6 +3,7 @@ package csv_test
 import (
 	"fmt"
 	"log"
+	"os"
 	"testing"
 
 	"github.com/ncruces/go-sqlite3"
@@ -56,7 +57,7 @@ func Example() {
 
 func TestMain(m *testing.M) {
 	sqlite3.AutoExtension(csv.Register)
-	m.Run()
+	os.Exit(m.Run())
 }
 
 func TestRegister(t *testing.T) {

ext/pivot/pivot_test.go

@@ -3,6 +3,7 @@ package pivot_test
 import (
 	"fmt"
 	"log"
+	"os"
 	"strings"
 	"testing"
 
@@ -85,7 +86,7 @@ func Example() {
 
 func TestMain(m *testing.M) {
 	sqlite3.AutoExtension(pivot.Register)
-	m.Run()
+	os.Exit(m.Run())
 }
 
 func TestRegister(t *testing.T) {

ext/statement/stmt_test.go

@@ -3,6 +3,7 @@ package statement_test
 import (
 	"fmt"
 	"log"
+	"os"
 	"testing"
 
 	"github.com/ncruces/go-sqlite3"
@@ -50,7 +51,7 @@ func Example() {
 
 func TestMain(m *testing.M) {
 	sqlite3.AutoExtension(statement.Register)
-	m.Run()
+	os.Exit(m.Run())
 }
 
 func TestRegister(t *testing.T) {

ext/stats/stats_test.go

@@ -2,6 +2,7 @@ package stats_test
 
 import (
 	"math"
+	"os"
 	"testing"
 
 	"github.com/ncruces/go-sqlite3"
@@ -12,7 +13,7 @@ import (
 
 func TestMain(m *testing.M) {
 	sqlite3.AutoExtension(stats.Register)
-	m.Run()
+	os.Exit(m.Run())
 }
 
 func TestRegister_variance(t *testing.T) {

go.mod

@@ -8,16 +8,16 @@ 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.36.0
-	golang.org/x/sys v0.31.0
+	golang.org/x/crypto v0.38.0
+	golang.org/x/sys v0.33.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.12.0 // test
-	golang.org/x/text v0.23.0 // ext/unicode
+	golang.org/x/sync v0.14.0 // test
+	golang.org/x/text v0.25.0 // ext/unicode
 	lukechampine.com/adiantum v1.1.1 // vfs/adiantum
 )
 

go.sum

@@ -10,13 +10,13 @@ github.com/psanford/httpreadat v0.1.0 h1:VleW1HS2zO7/4c7c7zNl33fO6oYACSagjJIyMIw
 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.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
-golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
-golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw=
-golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
-golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
-golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
-golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
+golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
+golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
+golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ=
+golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 lukechampine.com/adiantum v1.1.1 h1:4fp6gTxWCqpEbLy40ExiYDDED3oUNWx5cTqBCtPdZqA=
 lukechampine.com/adiantum v1.1.1/go.mod h1:LrAYVnTYLnUtE/yMp5bQr0HstAf060YUF8nM0B6+rUw=

gormlite/ddlmod.go

@@ -209,8 +209,12 @@ func (d *ddl) renameTable(dst, src string) error {
 	return nil
 }
 
+func compileConstraintRegexp(name string) *regexp.Regexp {
+	return regexp.MustCompile("^(?i:CONSTRAINT)\\s+[\"`]?" + regexp.QuoteMeta(name) + "[\"`\\s]")
+}
+
 func (d *ddl) addConstraint(name string, sql string) {
-	reg := regexp.MustCompile("^CONSTRAINT [\"`]?" + regexp.QuoteMeta(name) + "[\"` ]")
+	reg := compileConstraintRegexp(name)
 
 	for i := 0; i < len(d.fields); i++ {
 		if reg.MatchString(d.fields[i]) {
@@ -223,7 +227,7 @@ func (d *ddl) addConstraint(name string, sql string) {
 }
 
 func (d *ddl) removeConstraint(name string) bool {
-	reg := regexp.MustCompile("^CONSTRAINT [\"`]?" + regexp.QuoteMeta(name) + "[\"` ]")
+	reg := compileConstraintRegexp(name)
 
 	for i := 0; i < len(d.fields); i++ {
 		if reg.MatchString(d.fields[i]) {
@@ -236,7 +240,7 @@ func (d *ddl) removeConstraint(name string) bool {
 
 //lint:ignore U1000 ignore unused code.
 func (d *ddl) hasConstraint(name string) bool {
-	reg := regexp.MustCompile("^CONSTRAINT [\"`]?" + regexp.QuoteMeta(name) + "[\"` ]")
+	reg := compileConstraintRegexp(name)
 
 	for _, f := range d.fields {
 		if reg.MatchString(f) {

gormlite/ddlmod_parse_all_columns.go

@@ -95,7 +95,7 @@ func parseAllColumns(in string) ([]string, error) {
 			}
 			return nil, fmt.Errorf("unexpected token: %s", string(s[i]))
 		case parseAllColumnsState_State_End:
-			break
+			continue // avoid SA4011
 		}
 	}
 	if state != parseAllColumnsState_State_End {

gormlite/ddlmod_test.go

@@ -313,6 +313,41 @@ func TestRemoveConstraint(t *testing.T) {
 			success: true,
 			expect:  []string{"`id` integer NOT NULL"},
 		},
+		{
+			name:    "lowercase",
+			fields:  []string{"`id` integer NOT NULL", "constraint `fk_users_notes` FOREIGN KEY (`user_id`) REFERENCES `users`(`id`))"},
+			cName:   "fk_users_notes",
+			success: true,
+			expect:  []string{"`id` integer NOT NULL"},
+		},
+		{
+			name:    "mixed_case",
+			fields:  []string{"`id` integer NOT NULL", "cOnsTraiNT `fk_users_notes` FOREIGN KEY (`user_id`) REFERENCES `users`(`id`))"},
+			cName:   "fk_users_notes",
+			success: true,
+			expect:  []string{"`id` integer NOT NULL"},
+		},
+		{
+			name:    "newline",
+			fields:  []string{"`id` integer NOT NULL", "CONSTRAINT `fk_users_notes`\nFOREIGN KEY (`user_id`) REFERENCES `users`(`id`))"},
+			cName:   "fk_users_notes",
+			success: true,
+			expect:  []string{"`id` integer NOT NULL"},
+		},
+		{
+			name:    "lots_of_newlines",
+			fields:  []string{"`id` integer NOT NULL", "constraint \n    fk_users_notes \n   FOREIGN KEY (`user_id`) REFERENCES `users`(`id`))"},
+			cName:   "fk_users_notes",
+			success: true,
+			expect:  []string{"`id` integer NOT NULL"},
+		},
+		{
+			name:    "no_backtick",
+			fields:  []string{"`id` integer NOT NULL", "CONSTRAINT fk_users_notes FOREIGN KEY (`user_id`) REFERENCES `users`(`id`))"},
+			cName:   "fk_users_notes",
+			success: true,
+			expect:  []string{"`id` integer NOT NULL"},
+		},
 		{
 			name:    "check",
 			fields:  []string{"CONSTRAINT `name_checker` CHECK (`name` <> 'thetadev')", "`id` integer NOT NULL"},

gormlite/go.mod

@@ -5,7 +5,7 @@ go 1.23.0
 toolchain go1.24.0
 
 require (
-	github.com/ncruces/go-sqlite3 v0.24.0
+	github.com/ncruces/go-sqlite3 v0.25.0
 	gorm.io/gorm v1.25.12
 )
 
@@ -14,6 +14,6 @@ require (
 	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.30.0 // indirect
-	golang.org/x/text v0.22.0 // indirect
+	golang.org/x/sys v0.32.0 // indirect
+	golang.org/x/text v0.24.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.24.0 h1:Z4jfmzu2NCd4SmyFwLT2OmF3EnTZbqwATvdiuNHNhLA=
-github.com/ncruces/go-sqlite3 v0.24.0/go.mod h1:/Vs8ACZHjJ1SA6E9RZUn3EyB1OP3nDQ4z/ar+0fplTQ=
+github.com/ncruces/go-sqlite3 v0.25.0 h1:trugKUs98Zwy9KwRr/EUxZHL92LYt7UqcKqAfpGpK+I=
+github.com/ncruces/go-sqlite3 v0.25.0/go.mod h1:n6Z7036yFilJx04yV0mi5JWaF66rUmXn1It9Ux8dx68=
 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.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
-golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
-golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
+golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
+golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
+golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
 gorm.io/gorm v1.25.12 h1:I0u8i2hWQItBq1WfE0o2+WuL9+8L21K9e2HHSTE/0f8=
 gorm.io/gorm v1.25.12/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ=

gormlite/update.sh

@@ -11,5 +11,4 @@ curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.7/error_translator.go"
 curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.7/migrator.go"
 curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.7/sqlite.go"
 curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.7/sqlite_test.go"
-curl -#OL "https://github.com/go-gorm/sqlite/raw/v1.5.7/sqlite_test.go"
 curl -#L "https://github.com/glebarez/sqlite/raw/v1.11.0/sqlite_error_translator_test.go" > error_translator_test.go

sqlite3/busy_timeout.patch

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

sqlite3/download.sh

@@ -3,7 +3,7 @@ set -euo pipefail
 
 cd -P -- "$(dirname -- "$0")"
 
-curl -#OL "https://sqlite.org/2025/sqlite-amalgamation-3490100.zip"
+curl -#OL "https://sqlite.org/2025/sqlite-amalgamation-3500000.zip"
 unzip -d . sqlite-amalgamation-*.zip
 mv sqlite-amalgamation-*/sqlite3.c .
 mv sqlite-amalgamation-*/sqlite3.h .
@@ -19,30 +19,30 @@ rm -rf sqlite-amalgamation-*
 
 mkdir -p ext/
 cd ext/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/ext/misc/anycollseq.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/ext/misc/base64.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/ext/misc/decimal.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/ext/misc/ieee754.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/ext/misc/regexp.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/ext/misc/series.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/ext/misc/spellfix.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/ext/misc/uint.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.0/ext/misc/anycollseq.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.0/ext/misc/base64.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.0/ext/misc/decimal.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.0/ext/misc/ieee754.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.0/ext/misc/regexp.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.0/ext/misc/series.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.0/ext/misc/spellfix.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.0/ext/misc/uint.c"
 cd ~-
 
 cd ../vfs/tests/mptest/testdata/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/mptest/config01.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/mptest/config02.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/mptest/crash01.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/mptest/crash02.subtest"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/mptest/multiwrite01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.0/mptest/config01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.0/mptest/config02.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.0/mptest/crash01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.0/mptest/crash02.subtest"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.0/mptest/multiwrite01.test"
 cd ~-
 
 cd ../vfs/tests/mptest/wasm/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/mptest/mptest.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.0/mptest/mptest.c"
 cd ~-
 
 cd ../vfs/tests/speedtest1/wasm/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.49.1/test/speedtest1.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.50.0/test/speedtest1.c"
 cd ~-
 
 cat *.patch | patch -p0 --no-backup-if-mismatch

sqlite3/libc/benchmark.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd -P -- "$(dirname -- "$0")"
+
+touch empty.S
+./build.sh empty.S
+go test -bench=.
+rm -f empty.S
+
+./build.sh
+go test -bench=.

sqlite3/libc/build.sh

@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd -P -- "$(dirname -- "$0")"
+
+ROOT=../../
+BINARYEN="$ROOT/tools/binaryen/bin"
+WASI_SDK="$ROOT/tools/wasi-sdk/bin"
+SRCS="${1:-libc.c}"
+"../tools.sh"
+
+trap 'rm -f libc.c libc.tmp' EXIT
+cat << EOF > libc.c
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+EOF
+
+"$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -g0 -O2 \
+	-Wall -Wextra -Wno-unused-parameter -Wno-unused-function \
+	-o libc.wasm -I. "$SRCS" \
+	-mexec-model=reactor \
+	-mmutable-globals -mnontrapping-fptoint \
+	-msimd128 -mbulk-memory -msign-ext \
+	-mreference-types -mmultivalue \
+	-fno-stack-protector -fno-stack-clash-protection \
+	-Wl,-z,stack-size=4096 \
+	-Wl,--stack-first \
+	-Wl,--import-undefined \
+	-Wl,--initial-memory=16777216 \
+	-Wl,--export=memccpy \
+	-Wl,--export=memchr \
+	-Wl,--export=memcmp \
+	-Wl,--export=memcpy \
+	-Wl,--export=memmem \
+	-Wl,--export=memmove \
+	-Wl,--export=memrchr \
+	-Wl,--export=memset \
+	-Wl,--export=stpcpy \
+	-Wl,--export=stpncpy \
+	-Wl,--export=strcasecmp \
+	-Wl,--export=strcasestr \
+	-Wl,--export=strchr \
+	-Wl,--export=strchrnul \
+	-Wl,--export=strcmp \
+	-Wl,--export=strcpy \
+	-Wl,--export=strcspn \
+	-Wl,--export=strlen \
+	-Wl,--export=strncasecmp \
+	-Wl,--export=strncat \
+	-Wl,--export=strncmp \
+	-Wl,--export=strncpy \
+	-Wl,--export=strrchr \
+	-Wl,--export=strspn \
+	-Wl,--export=strstr \
+	-Wl,--export=qsort
+
+"$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 \
+	--enable-mutable-globals --enable-nontrapping-float-to-int \
+	--enable-simd --enable-bulk-memory --enable-sign-ext \
+	--enable-reference-types --enable-multivalue
+
+"$BINARYEN/wasm-dis" -o libc.wat libc.wasm

sqlite3/libc/math.h

@@ -0,0 +1,36 @@
+#include_next <math.h>  // the system math.h
+
+#ifndef _WASM_SIMD128_MATH_H
+#define _WASM_SIMD128_MATH_H
+
+#include <wasm_simd128.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __wasm_relaxed_simd__
+
+// This header assumes "relaxed fused multiply-add"
+// is both faster and more precise.
+
+#define FP_FAST_FMA 1
+
+__attribute__((weak))
+double fma(double x, double y, double z) {
+  // If we get a software implementation from the host,
+  // this is enough to short circuit it on the 2nd lane.
+  const v128_t wx = wasm_f64x2_replace_lane(b, 0, x);
+  const v128_t wy = wasm_f64x2_splat(y);
+  const v128_t wz = wasm_f64x2_splat(z);
+  const v128_t wr = wasm_f64x2_relaxed_madd(wx, wy, wz);
+  return wasm_f64x2_extract_lane(wr, 0);
+}
+
+#endif  // __wasm_relaxed_simd__
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // _WASM_SIMD128_MATH_H

sqlite3/libc/stdlib.h

@@ -0,0 +1,57 @@
+#include_next <stdlib.h>  // the system stdlib.h
+
+#ifndef _WASM_SIMD128_STDLIB_H
+#define _WASM_SIMD128_STDLIB_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Shellsort with Gonnet & Baeza-Yates gap sequence.
+// Simple, no recursion, doesn't use the C stack.
+// Clang auto-vectorizes the inner loop.
+
+__attribute__((weak))
+void qsort(void *base, size_t nel, size_t width,
+           int (*comp)(const void *, const void *)) {
+  // If nel is zero, we're required to do nothing.
+  // If it's one, the array is already sorted.
+  size_t wnel = width * nel;
+  size_t gap = nel;
+  while (gap > 1) {
+    // Use 64-bit unsigned arithmetic to avoid intermediate overflow.
+    // Absent overflow, gap will be strictly less than its previous value.
+    // Once it is one or zero, set it to one: do a final pass, and stop.
+    gap = (5ull * gap - 1) / 11;
+    if (gap == 0) gap = 1;
+
+    // It'd be undefined behavior for wnel to overflow a size_t;
+    // or if width is zero: the base pointer would be invalid.
+    // Since gap is stricly less than nel, we can assume
+    // wgap is strictly less than wnel.
+    size_t wgap = width * gap;
+    __builtin_assume(wgap < wnel);
+    for (size_t i = wgap; i < wnel; i += width) {
+      // Even without overflow flags, the overflow builtin helps the compiler.
+      for (size_t j = i; !__builtin_sub_overflow(j, wgap, &j);) {
+        char *a = j + (char *)base;
+        char *b = a + wgap;
+        if (comp(a, b) <= 0) break;
+
+        // This well known loop is automatically vectorized.
+        size_t s = width;
+        do {
+          char tmp = *a;
+          *a++ = *b;
+          *b++ = tmp;
+        } while (--s);
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // _WASM_SIMD128_STDLIB_H

sqlite3/libc/string.h

@@ -0,0 +1,752 @@
+#include_next <string.h>  // the system string.h
+
+#ifndef _WASM_SIMD128_STRING_H
+#define _WASM_SIMD128_STRING_H
+
+#include <ctype.h>
+#include <stdint.h>
+#include <strings.h>
+#include <wasm_simd128.h>
+#include <__macro_PAGESIZE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __wasm_bulk_memory__
+
+// Use the builtins if compiled with bulk memory operations.
+// Clang will intrinsify using SIMD for small, constant N.
+// For everything else, this helps inlining.
+
+__attribute__((weak))
+void *memset(void *dest, int c, size_t n) {
+  return __builtin_memset(dest, c, n);
+}
+
+__attribute__((weak))
+void *memcpy(void *__restrict dest, const void *__restrict src, size_t n) {
+  return __builtin_memcpy(dest, src, n);
+}
+
+__attribute__((weak))
+void *memmove(void *dest, const void *src, size_t n) {
+  return __builtin_memmove(dest, src, n);
+}
+
+#endif  // __wasm_bulk_memory__
+
+#ifdef __wasm_simd128__
+
+__attribute__((weak))
+int memcmp(const void *v1, const void *v2, size_t n) {
+  // Scalar algorithm.
+  if (n < sizeof(v128_t)) {
+    const unsigned char *u1 = (unsigned char *)v1;
+    const unsigned char *u2 = (unsigned char *)v2;
+    while (n--) {
+      if (*u1 != *u2) return *u1 - *u2;
+      u1++;
+      u2++;
+    }
+    return 0;
+  }
+
+  // memcmp is allowed to read up to n bytes from each object.
+  // Find the first different character in the objects.
+  // Unaligned loads handle the case where the objects
+  // have mismatching alignments.
+  const v128_t *w1 = (v128_t *)v1;
+  const v128_t *w2 = (v128_t *)v2;
+  while (n) {
+    const v128_t cmp = wasm_i8x16_eq(wasm_v128_load(w1), wasm_v128_load(w2));
+    // Bitmask is slow on AArch64, all_true is much faster.
+    if (!wasm_i8x16_all_true(cmp)) {
+      // Find the offset of the first zero bit (little-endian).
+      size_t ctz = __builtin_ctz(~wasm_i8x16_bitmask(cmp));
+      const unsigned char *u1 = (unsigned char *)w1 + ctz;
+      const unsigned char *u2 = (unsigned char *)w2 + ctz;
+      // This may help the compiler if the function is inlined.
+      __builtin_assume(*u1 - *u2 != 0);
+      return *u1 - *u2;
+    }
+    // This makes n a multiple of sizeof(v128_t)
+    // for every iteration except the first.
+    size_t align = (n - 1) % sizeof(v128_t) + 1;
+    w1 = (v128_t *)((char *)w1 + align);
+    w2 = (v128_t *)((char *)w2 + align);
+    n -= align;
+  }
+  return 0;
+}
+
+__attribute__((weak))
+void *memchr(const void *v, int c, size_t n) {
+  // When n is zero, a function that locates a character finds no occurrence.
+  // Otherwise, decrement n to ensure sub_overflow overflows
+  // when n would go equal-to-or-below zero.
+  if (!n--) {
+    return NULL;
+  }
+
+  // memchr must behave as if it reads characters sequentially
+  // and stops as soon as a match is found.
+  // Aligning ensures loads beyond the first match are safe.
+  uintptr_t align = (uintptr_t)v % sizeof(v128_t);
+  const v128_t *w = (v128_t *)((char *)v - align);
+  const v128_t wc = wasm_i8x16_splat(c);
+
+  for (;;) {
+    const v128_t cmp = wasm_i8x16_eq(*w, wc);
+    // Bitmask is slow on AArch64, any_true is much faster.
+    if (wasm_v128_any_true(cmp)) {
+      // Clear the bits corresponding to alignment (little-endian)
+      // so we can count trailing zeros.
+      int mask = wasm_i8x16_bitmask(cmp) >> align << align;
+      // At least one bit will be set, unless we cleared them.
+      // Knowing this helps the compiler.
+      __builtin_assume(mask || align);
+      // If the mask is zero because of alignment,
+      // it's as if we didn't find anything.
+      if (mask) {
+        // Find the offset of the first one bit (little-endian).
+        // That's a match, unless it is beyond the end of the object.
+        // Recall that we decremented n, so less-than-or-equal-to is correct.
+        size_t ctz = __builtin_ctz(mask);
+        return ctz <= n + align ? (char *)w + ctz : NULL;
+      }
+    }
+    // Decrement n; if it overflows we're done.
+    if (__builtin_sub_overflow(n, sizeof(v128_t) - align, &n)) {
+      return NULL;
+    }
+    align = 0;
+    w++;
+  }
+}
+
+__attribute__((weak))
+void *memrchr(const void *v, int c, size_t n) {
+  // memrchr is allowed to read up to n bytes from the object.
+  // Search backward for the last matching character.
+  const v128_t *w = (v128_t *)((char *)v + n);
+  const v128_t wc = wasm_i8x16_splat(c);
+  for (; n >= sizeof(v128_t); n -= sizeof(v128_t)) {
+    const v128_t cmp = wasm_i8x16_eq(wasm_v128_load(--w), wc);
+    // Bitmask is slow on AArch64, any_true is much faster.
+    if (wasm_v128_any_true(cmp)) {
+      // Find the offset of the last one bit (little-endian).
+      size_t clz = __builtin_clz(wasm_i8x16_bitmask(cmp)) - 15;
+      return (char *)(w + 1) - clz;
+    }
+  }
+
+  // Scalar algorithm.
+  const char *a = (char *)w;
+  while (n--) {
+    if (*(--a) == (char)c) return (char *)a;
+  }
+  return NULL;
+}
+
+__attribute__((weak))
+size_t strlen(const char *s) {
+  // strlen must stop as soon as it finds the terminator.
+  // Aligning ensures loads beyond the terminator are safe.
+  uintptr_t align = (uintptr_t)s % sizeof(v128_t);
+  const v128_t *w = (v128_t *)(s - align);
+
+  for (;;) {
+    // Bitmask is slow on AArch64, all_true is much faster.
+    if (!wasm_i8x16_all_true(*w)) {
+      const v128_t cmp = wasm_i8x16_eq(*w, (v128_t){});
+      // Clear the bits corresponding to alignment (little-endian)
+      // so we can count trailing zeros.
+      int mask = wasm_i8x16_bitmask(cmp) >> align << align;
+      // At least one bit will be set, unless we cleared them.
+      // Knowing this helps the compiler.
+      __builtin_assume(mask || align);
+      if (mask) {
+        // Find the offset of the first one bit (little-endian).
+        return (char *)w - s + __builtin_ctz(mask);
+      }
+    }
+    align = 0;
+    w++;
+  }
+}
+
+static int __strcmp_s(const char *s1, const char *s2) {
+  // Scalar algorithm.
+  const unsigned char *u1 = (unsigned char *)s1;
+  const unsigned char *u2 = (unsigned char *)s2;
+  for (;;) {
+    if (*u1 != *u2) return *u1 - *u2;
+    if (*u1 == 0) break;
+    u1++;
+    u2++;
+  }
+  return 0;
+}
+
+static int __strcmp(const char *s1, const char *s2) {
+  // How many bytes can be read before pointers go out of bounds.
+  size_t N = __builtin_wasm_memory_size(0) * PAGESIZE -  //
+             (size_t)(s1 > s2 ? s1 : s2);
+
+  // Unaligned loads handle the case where the strings
+  // have mismatching alignments.
+  const v128_t *w1 = (v128_t *)s1;
+  const v128_t *w2 = (v128_t *)s2;
+  for (; N >= sizeof(v128_t); N -= sizeof(v128_t)) {
+    // Find any single bit difference.
+    if (wasm_v128_any_true(wasm_v128_load(w1) ^ wasm_v128_load(w2))) {
+      // The terminator may come before the difference.
+      break;
+    }
+    // We know all characters are equal.
+    // If any is a terminator the strings are equal.
+    if (!wasm_i8x16_all_true(wasm_v128_load(w1))) {
+      return 0;
+    }
+    w1++;
+    w2++;
+  }
+
+  return __strcmp_s((char *)w1, (char *)w2);
+}
+
+__attribute__((weak, always_inline))
+int strcmp(const char *s1, const char *s2) {
+  // Skip the vector search when comparing against small literal strings.
+  if (__builtin_constant_p(strlen(s2)) && strlen(s2) < sizeof(v128_t)) {
+    return __strcmp_s(s1, s2);
+  }
+  return __strcmp(s1, s2);
+}
+
+__attribute__((weak))
+int strncmp(const char *s1, const char *s2, size_t n) {
+  // How many bytes can be read before pointers go out of bounds.
+  size_t N = __builtin_wasm_memory_size(0) * PAGESIZE -  //
+             (size_t)(s1 > s2 ? s1 : s2);
+  if (n > N) n = N;
+
+  // Unaligned loads handle the case where the strings
+  // have mismatching alignments.
+  const v128_t *w1 = (v128_t *)s1;
+  const v128_t *w2 = (v128_t *)s2;
+  for (; n >= sizeof(v128_t); n -= sizeof(v128_t)) {
+    // Find any single bit difference.
+    if (wasm_v128_any_true(wasm_v128_load(w1) ^ wasm_v128_load(w2))) {
+      // The terminator may come before the difference.
+      break;
+    }
+    // We know all characters are equal.
+    // If any is a terminator the strings are equal.
+    if (!wasm_i8x16_all_true(wasm_v128_load(w1))) {
+      return 0;
+    }
+    w1++;
+    w2++;
+  }
+
+  // Scalar algorithm.
+  const unsigned char *u1 = (unsigned char *)w1;
+  const unsigned char *u2 = (unsigned char *)w2;
+  while (n--) {
+    if (*u1 != *u2) return *u1 - *u2;
+    if (*u1 == 0) break;
+    u1++;
+    u2++;
+  }
+  return 0;
+}
+
+static char *__strchrnul(const char *s, int c) {
+  // strchrnul must stop as soon as a match is found.
+  // Aligning ensures loads beyond the first match are safe.
+  uintptr_t align = (uintptr_t)s % sizeof(v128_t);
+  const v128_t *w = (v128_t *)(s - align);
+  const v128_t wc = wasm_i8x16_splat(c);
+
+  for (;;) {
+    const v128_t cmp = wasm_i8x16_eq(*w, (v128_t){}) | wasm_i8x16_eq(*w, wc);
+    // Bitmask is slow on AArch64, any_true is much faster.
+    if (wasm_v128_any_true(cmp)) {
+      // Clear the bits corresponding to alignment (little-endian)
+      // so we can count trailing zeros.
+      int mask = wasm_i8x16_bitmask(cmp) >> align << align;
+      // At least one bit will be set, unless we cleared them.
+      // Knowing this helps the compiler.
+      __builtin_assume(mask || align);
+      if (mask) {
+        // Find the offset of the first one bit (little-endian).
+        return (char *)w + __builtin_ctz(mask);
+      }
+    }
+    align = 0;
+    w++;
+  }
+}
+
+__attribute__((weak, always_inline))
+char *strchrnul(const char *s, int c) {
+  // For finding the terminator, strlen is faster.
+  if (__builtin_constant_p(c) && (char)c == 0) {
+    return (char *)s + strlen(s);
+  }
+  return __strchrnul(s, c);
+}
+
+__attribute__((weak, always_inline))
+char *strchr(const char *s, int c) {
+  // For finding the terminator, strlen is faster.
+  if (__builtin_constant_p(c) && (char)c == 0) {
+    return (char *)s + strlen(s);
+  }
+  char *r = __strchrnul(s, c);
+  return *r == (char)c ? r : NULL;
+}
+
+__attribute__((weak, always_inline))
+char *strrchr(const char *s, int c) {
+  // For finding the terminator, strlen is faster.
+  if (__builtin_constant_p(c) && (char)c == 0) {
+    return (char *)s + strlen(s);
+  }
+  // This could also be implemented in a single pass using strchr,
+  // advancing to the next match until no more matches are found.
+  // That would be suboptimal with lots of consecutive matches.
+  return (char *)memrchr(s, c, strlen(s) + 1);
+}
+
+// SIMDized check which bytes are in a set
+// http://0x80.pl/notesen/2018-10-18-simd-byte-lookup.html
+
+typedef struct {
+  __u8x16 l;
+  __u8x16 h;
+} __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->l[lo_nibble] |= 1 << (hi_nibble - 0);
+  bitmap->h[lo_nibble] |= 1 << (hi_nibble - 8);
+}
+
+__attribute__((always_inline))
+static int __wasm_v128_chkbit(__wasm_v128_bitmap256_t bitmap, int i) {
+  uint8_t hi_nibble = (uint8_t)i >> 4;
+  uint8_t lo_nibble = (uint8_t)i & 0xf;
+  uint8_t bitmask = 1 << (hi_nibble & 0x7);
+  uint8_t bitset = (hi_nibble < 8 ? bitmap.l : bitmap.h)[lo_nibble];
+  return bitmask & bitset;
+}
+
+#ifndef __wasm_relaxed_simd__
+
+#define wasm_i8x16_relaxed_laneselect wasm_v128_bitselect
+#define wasm_i8x16_relaxed_swizzle wasm_i8x16_swizzle
+
+#endif  // __wasm_relaxed_simd__
+
+__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 lo_nibbles = v & wasm_u8x16_const_splat(0xf);
+
+  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 = wasm_i8x16_relaxed_swizzle(bitmask_lookup, hi_nibbles);
+  v128_t bitsets = wasm_i8x16_relaxed_laneselect(
+      wasm_i8x16_relaxed_swizzle(bitmap.l, lo_nibbles),
+      wasm_i8x16_relaxed_swizzle(bitmap.h, lo_nibbles),
+      wasm_i8x16_lt(hi_nibbles, wasm_u8x16_const_splat(8)));
+
+  return wasm_i8x16_eq(bitsets & bitmask, bitmask);
+}
+
+#undef wasm_i8x16_relaxed_laneselect
+#undef wasm_i8x16_relaxed_swizzle
+
+__attribute__((weak))
+size_t strspn(const char *s, const char *c) {
+  // How many bytes can be read before the pointer goes out of bounds.
+  size_t N = __builtin_wasm_memory_size(0) * PAGESIZE - (size_t)s;
+  const v128_t *w = (v128_t *)s;
+  const char *const a = s;
+
+  if (!c[0]) return 0;
+  if (!c[1]) {
+    const v128_t wc = wasm_i8x16_splat(*c);
+    for (; N >= sizeof(v128_t); N -= sizeof(v128_t)) {
+      const v128_t cmp = wasm_i8x16_eq(wasm_v128_load(w), wc);
+      // Bitmask is slow on AArch64, all_true is much faster.
+      if (!wasm_i8x16_all_true(cmp)) {
+        // Find the offset of the first zero bit (little-endian).
+        size_t ctz = __builtin_ctz(~wasm_i8x16_bitmask(cmp));
+        return (char *)w + ctz - s;
+      }
+      w++;
+    }
+
+    // Scalar algorithm.
+    for (s = (char *)w; *s == *c; s++);
+    return s - a;
+  }
+
+  __wasm_v128_bitmap256_t bitmap = {};
+
+  for (; *c; c++) {
+    __wasm_v128_setbit(&bitmap, *c);
+    // Terminator IS NOT on the bitmap.
+  }
+
+  for (; N >= sizeof(v128_t); N -= sizeof(v128_t)) {
+    const v128_t cmp = __wasm_v128_chkbits(bitmap, wasm_v128_load(w));
+    // Bitmask is slow on AArch64, all_true is much faster.
+    if (!wasm_i8x16_all_true(cmp)) {
+      // Find the offset of the first zero bit (little-endian).
+      size_t ctz = __builtin_ctz(~wasm_i8x16_bitmask(cmp));
+      return (char *)w + ctz - s;
+    }
+    w++;
+  }
+
+  // Scalar algorithm.
+  for (s = (char *)w; __wasm_v128_chkbit(bitmap, *s); s++);
+  return s - a;
+}
+
+__attribute__((weak))
+size_t strcspn(const char *s, const char *c) {
+  if (!c[0] || !c[1]) return __strchrnul(s, *c) - s;
+
+  // How many bytes can be read before the pointer goes out of bounds.
+  size_t N = __builtin_wasm_memory_size(0) * PAGESIZE - (size_t)s;
+  const v128_t *w = (v128_t *)s;
+  const char *const a = s;
+
+  __wasm_v128_bitmap256_t bitmap = {};
+
+  for (;;) {
+    __wasm_v128_setbit(&bitmap, *c);
+    // Terminator IS on the bitmap.
+    if (!*c++) break;
+  }
+
+  for (; N >= sizeof(v128_t); N -= sizeof(v128_t)) {
+    const v128_t cmp = __wasm_v128_chkbits(bitmap, wasm_v128_load(w));
+    // Bitmask is slow on AArch64, any_true is much faster.
+    if (wasm_v128_any_true(cmp)) {
+      // Find the offset of the first one bit (little-endian).
+      size_t ctz = __builtin_ctz(wasm_i8x16_bitmask(cmp));
+      return (char *)w + ctz - s;
+    }
+    w++;
+  }
+
+  // Scalar algorithm.
+  for (s = (char *)w; !__wasm_v128_chkbit(bitmap, *s); s++);
+  return s - a;
+}
+
+// SIMD-friendly algorithms for substring searching
+// http://0x80.pl/notesen/2016-11-28-simd-strfind.html
+
+// For haystacks of known length and large enough needles,
+// Boyer-Moore's bad-character rule may be useful,
+// as proposed by Horspool, Sunday and Raita.
+//
+// We augment the SIMD algorithm with Quick Search's
+// bad-character shift.
+//
+// https://www-igm.univ-mlv.fr/~lecroq/string/node14.html
+// https://www-igm.univ-mlv.fr/~lecroq/string/node18.html
+// https://www-igm.univ-mlv.fr/~lecroq/string/node19.html
+// https://www-igm.univ-mlv.fr/~lecroq/string/node22.html
+
+static const char *__memmem(const char *haystk, size_t sh,
+                            const char *needle, size_t sn,
+                            uint8_t bmbc[256]) {
+  // We've handled empty and single character needles.
+  // The needle is not longer than the haystack.
+  __builtin_assume(2 <= sn && sn <= sh);
+
+  // Find the farthest character not equal to the first one.
+  size_t i = sn - 1;
+  while (i > 0 && needle[0] == needle[i]) i--;
+  if (i == 0) i = sn - 1;
+
+  // Subtracting ensures sub_overflow overflows
+  // when we reach the end of the haystack.
+  if (sh != SIZE_MAX) sh -= sn;
+
+  const v128_t fst = wasm_i8x16_splat(needle[0]);
+  const v128_t lst = wasm_i8x16_splat(needle[i]);
+
+  // The last haystack offset for which loading blk_lst is safe.
+  const char *H = (char *)(__builtin_wasm_memory_size(0) * PAGESIZE - i -
+                           sizeof(v128_t));
+
+  while (haystk <= H) {
+    const v128_t blk_fst = wasm_v128_load((v128_t *)(haystk));
+    const v128_t blk_lst = wasm_v128_load((v128_t *)(haystk + i));
+    const v128_t eq_fst = wasm_i8x16_eq(fst, blk_fst);
+    const v128_t eq_lst = wasm_i8x16_eq(lst, blk_lst);
+
+    const v128_t cmp = eq_fst & eq_lst;
+    if (wasm_v128_any_true(cmp)) {
+      // The terminator may come before the match.
+      if (sh == SIZE_MAX && !wasm_i8x16_all_true(blk_fst)) break;
+      // Find the offset of the first one bit (little-endian).
+      // Each iteration clears that bit, tries again.
+      for (uint32_t mask = wasm_i8x16_bitmask(cmp); mask; mask &= mask - 1) {
+        size_t ctz = __builtin_ctz(mask);
+        // The match may be after the end of the haystack.
+        if (ctz > sh) return NULL;
+        // We know the first character matches.
+        if (!bcmp(haystk + ctz + 1, needle + 1, sn - 1)) {
+          return haystk + ctz;
+        }
+      }
+    }
+
+    size_t skip = sizeof(v128_t);
+    if (sh == SIZE_MAX) {
+      // Have we reached the end of the haystack?
+      if (!wasm_i8x16_all_true(blk_fst)) return NULL;
+    } else {
+      // Apply the bad-character rule to the character to the right
+      // of the righmost character of the search window.
+      if (bmbc) skip += bmbc[(unsigned char)haystk[sn - 1 + sizeof(v128_t)]];
+      // Have we reached the end of the haystack?
+      if (__builtin_sub_overflow(sh, skip, &sh)) return NULL;
+    }
+    haystk += skip;
+  }
+
+  // Scalar algorithm.
+  for (size_t j = 0; j <= sh; j++) {
+    for (size_t i = 0;; i++) {
+      if (sn == i) return haystk;
+      if (sh == SIZE_MAX && !haystk[i]) return NULL;
+      if (needle[i] != haystk[i]) break;
+    }
+    haystk++;
+  }
+  return NULL;
+}
+
+__attribute__((weak))
+void *memmem(const void *vh, size_t sh, const void *vn, size_t sn) {
+  // Return immediately on empty needle.
+  if (sn == 0) return (void *)vh;
+
+  // Return immediately when needle is longer than haystack.
+  if (sn > sh) return NULL;
+
+  // Skip to the first matching character using memchr,
+  // thereby handling single character needles.
+  const char *needle = (char *)vn;
+  const char *haystk = (char *)memchr(vh, *needle, sh);
+  if (!haystk || sn == 1) return (void *)haystk;
+
+  // The haystack got shorter, is the needle now longer than it?
+  sh -= haystk - (char *)vh;
+  if (sn > sh) return NULL;
+
+  // Is Boyer-Moore's bad-character rule useful?
+  if (sn < sizeof(v128_t) || sh - sn < sizeof(v128_t)) {
+    return (void *)__memmem(haystk, sh, needle, sn, NULL);
+  }
+
+  // Compute Boyer-Moore's bad-character shift function.
+  // Only the last 255 characters of the needle matter for shifts up to 255,
+  // which is good enough for most needles.
+  size_t c = sn;
+  size_t i = 0;
+  if (c >= 255) {
+    i = sn - 255;
+    c = 255;
+  }
+
+#ifndef _REENTRANT
+  static
+#endif
+  uint8_t bmbc[256];
+  memset(bmbc, c, sizeof(bmbc));
+  for (; i < sn; i++) {
+    // One less than the usual offset because
+    // we advance at least one vector at a time.
+    bmbc[(unsigned char)needle[i]] = sn - i - 1;
+  }
+
+  return (void *)__memmem(haystk, sh, needle, sn, bmbc);
+}
+
+__attribute__((weak))
+char *strstr(const char *haystk, const char *needle) {
+  // Return immediately on empty needle.
+  if (!needle[0]) return (char *)haystk;
+
+  // Skip to the first matching character using strchr,
+  // thereby handling single character needles.
+  haystk = strchr(haystk, *needle);
+  if (!haystk || !needle[1]) return (char *)haystk;
+
+  return (char *)__memmem(haystk, SIZE_MAX, needle, strlen(needle), NULL);
+}
+
+__attribute__((weak))
+char *strcasestr(const char *haystk, const char *needle) {
+  // Return immediately on empty needle.
+  if (!needle[0]) return (char *)haystk;
+
+  // We've handled empty needles.
+  size_t sn = strlen(needle);
+  __builtin_assume(sn >= 1);
+
+  // Find the farthest character not equal to the first one.
+  size_t i = sn - 1;
+  while (i > 0 && needle[0] == needle[i]) i--;
+  if (i == 0) i = sn - 1;
+
+  const v128_t fst = wasm_i8x16_splat(tolower(needle[0]));
+  const v128_t lst = wasm_i8x16_splat(tolower(needle[i]));
+
+  // The last haystk offset for which loading blk_lst is safe.
+  const char *H =
+      (char *)(__builtin_wasm_memory_size(0) * PAGESIZE - i - sizeof(v128_t));
+
+  while (haystk <= H) {
+    const v128_t blk_fst = __tolower8x16(wasm_v128_load((v128_t *)(haystk)));
+    const v128_t blk_lst = __tolower8x16(wasm_v128_load((v128_t *)(haystk + i)));
+    const v128_t eq_fst = wasm_i8x16_eq(fst, blk_fst);
+    const v128_t eq_lst = wasm_i8x16_eq(lst, blk_lst);
+
+    const v128_t cmp = eq_fst & eq_lst;
+    if (wasm_v128_any_true(cmp)) {
+      // The terminator may come before the match.
+      if (!wasm_i8x16_all_true(blk_fst)) break;
+      // Find the offset of the first one bit (little-endian).
+      // Each iteration clears that bit, tries again.
+      for (uint32_t mask = wasm_i8x16_bitmask(cmp); mask; mask &= mask - 1) {
+        size_t ctz = __builtin_ctz(mask);
+        if (!strncasecmp(haystk + ctz + 1, needle + 1, sn - 1)) {
+          return (char *)haystk + ctz;
+        }
+      }
+    }
+
+    // Have we reached the end of the haystack?
+    if (!wasm_i8x16_all_true(blk_fst)) return NULL;
+    haystk += sizeof(v128_t);
+  }
+
+  // Scalar algorithm.
+  for (;;) {
+    for (size_t i = 0;; i++) {
+      if (sn == i) return (char *)haystk;
+      if (!haystk[i]) return NULL;
+      if (tolower(needle[i]) != tolower(haystk[i])) break;
+    }
+    haystk++;
+  }
+  return NULL;
+}
+
+// Given the above SIMD implementations,
+// these are best implemented as
+// small wrappers over those functions.
+
+// Simple wrappers already in musl:
+//  - mempcpy
+//  - strcat
+//  - strlcat
+//  - strdup
+//  - strndup
+//  - strnlen
+//  - strpbrk
+//  - strsep
+//  - strtok
+
+__attribute__((weak))
+void *memccpy(void *__restrict dest, const void *__restrict src, int c, size_t n) {
+  const void *m = memchr(src, c, n);
+  if (m != NULL) {
+    n = (char *)m - (char *)src + 1;
+    m = (char *)dest + n;
+  }
+  memcpy(dest, src, n);
+  return (void *)m;
+}
+
+__attribute__((weak))
+size_t strlcpy(char *__restrict dest, const char *__restrict src, size_t n) {
+  size_t slen = strlen(src);
+  if (n--) {
+    if (n > slen) n = slen;
+    memcpy(dest, src, n);
+    dest[n] = 0;
+  }
+  return slen;
+}
+
+__attribute__((weak))
+char *strncat(char *__restrict dest, const char *__restrict src, size_t n) {
+  size_t strnlen(const char *s, size_t n);
+  size_t dlen = strlen(dest);
+  size_t slen = strnlen(src, n);
+  memcpy(dest + dlen, src, slen);
+  dest[dlen + slen] = 0;
+  return dest;
+}
+
+static char *__stpcpy(char *__restrict dest, const char *__restrict src) {
+  size_t slen = strlen(src);
+  memcpy(dest, src, slen + 1);
+  return dest + slen;
+}
+
+static char *__stpncpy(char *__restrict dest, const char *__restrict src, size_t n) {
+  size_t strnlen(const char *s, size_t n);
+  size_t slen = strnlen(src, n);
+  memcpy(dest, src, slen);
+  memset(dest + slen, 0, n - slen);
+  return dest + slen;
+}
+
+__attribute__((weak, always_inline))
+char *stpcpy(char *__restrict dest, const char *__restrict src) {
+  return __stpcpy(dest, src);
+}
+
+__attribute__((weak, always_inline))
+char *strcpy(char *__restrict dest, const char *__restrict src) {
+  __stpcpy(dest, src);
+  return dest;
+}
+
+__attribute__((weak, always_inline))
+char *stpncpy(char *__restrict dest, const char *__restrict src, size_t n) {
+  return __stpncpy(dest, src, n);
+}
+
+__attribute__((weak, always_inline))
+char *strncpy(char *__restrict dest, const char *__restrict src, size_t n) {
+  __stpncpy(dest, src, n);
+  return dest;
+}
+
+#endif  // __wasm_simd128__
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // _WASM_SIMD128_STRING_H

sqlite3/libc/strings.h

@@ -0,0 +1,171 @@
+#include_next <strings.h>  // the system strings.h
+
+#ifndef _WASM_SIMD128_STRINGS_H
+#define _WASM_SIMD128_STRINGS_H
+
+#include <ctype.h>
+#include <stdint.h>
+#include <wasm_simd128.h>
+#include <__macro_PAGESIZE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __wasm_simd128__
+
+#ifdef __OPTIMIZE_SIZE__
+
+// bcmp is the same as memcmp but only compares for equality.
+int bcmp(const void *v1, const void *v2, size_t n);
+
+#else  // __OPTIMIZE_SIZE__
+
+__attribute__((weak))
+int bcmp(const void *v1, const void *v2, size_t n) {
+  // Scalar algorithm.
+  if (n < sizeof(v128_t)) {
+    const unsigned char *u1 = (unsigned char *)v1;
+    const unsigned char *u2 = (unsigned char *)v2;
+    while (n--) {
+      if (*u1 != *u2) return 1;
+      u1++;
+      u2++;
+    }
+    return 0;
+  }
+
+  // bcmp is allowed to read up to n bytes from each object.
+  // Unaligned loads handle the case where the objects
+  // have mismatching alignments.
+  const v128_t *w1 = (v128_t *)v1;
+  const v128_t *w2 = (v128_t *)v2;
+  while (n) {
+    // Find any single bit difference.
+    if (wasm_v128_any_true(wasm_v128_load(w1) ^ wasm_v128_load(w2))) {
+      return 1;
+    }
+    // This makes n a multiple of sizeof(v128_t)
+    // for every iteration except the first.
+    size_t align = (n - 1) % sizeof(v128_t) + 1;
+    w1 = (v128_t *)((char *)w1 + align);
+    w2 = (v128_t *)((char *)w2 + align);
+    n -= align;
+  }
+  return 0;
+}
+
+#endif  // __OPTIMIZE_SIZE__
+
+static v128_t __tolower8x16(v128_t v) {
+  __i8x16 i = v;
+  i = i + wasm_i8x16_splat(INT8_MAX - ('Z'));
+  i = i > wasm_i8x16_splat(INT8_MAX - ('Z' - 'A' + 1));
+  i = i & wasm_i8x16_splat('a' - 'A');
+  return v | i;
+}
+
+static int __strcasecmp_s(const char *s1, const char *s2) {
+  // Scalar algorithm.
+  const unsigned char *u1 = (unsigned char *)s1;
+  const unsigned char *u2 = (unsigned char *)s2;
+  for (;;) {
+    int c1 = tolower(*u1);
+    int c2 = tolower(*u2);
+    if (c1 != c2) return c1 - c2;
+    if (c1 == 0) break;
+    u1++;
+    u2++;
+  }
+  return 0;
+}
+
+static int __strcasecmp(const char *s1, const char *s2) {
+  // How many bytes can be read before pointers go out of bounds.
+  size_t N = __builtin_wasm_memory_size(0) * PAGESIZE -  //
+             (size_t)(s1 > s2 ? s1 : s2);
+
+  // Unaligned loads handle the case where the strings
+  // have mismatching alignments.
+  const v128_t *w1 = (v128_t *)s1;
+  const v128_t *w2 = (v128_t *)s2;
+  for (; N >= sizeof(v128_t); N -= sizeof(v128_t)) {
+    v128_t v1 = __tolower8x16(wasm_v128_load(w1));
+    v128_t v2 = __tolower8x16(wasm_v128_load(w2));
+
+    // Find any single bit difference.
+    if (wasm_v128_any_true(v1 ^ v2)) {
+      // The terminator may come before the difference.
+      break;
+    }
+    // We know all characters are equal.
+    // If any is a terminator the strings are equal.
+    if (!wasm_i8x16_all_true(v1)) {
+      return 0;
+    }
+    w1++;
+    w2++;
+  }
+
+  return __strcasecmp_s((char *)w1, (char *)w2);
+}
+
+__attribute__((weak))
+int strcasecmp(const char *s1, const char *s2) {
+  // Skip the vector search when comparing against small literal strings.
+  if (__builtin_constant_p(strlen(s2)) && strlen(s2) < sizeof(v128_t)) {
+    return __strcasecmp_s(s1, s2);
+  }
+  return __strcasecmp(s1, s2);
+}
+
+__attribute__((weak))
+int strncasecmp(const char *s1, const char *s2, size_t n) {
+  // How many bytes can be read before pointers go out of bounds.
+  size_t N = __builtin_wasm_memory_size(0) * PAGESIZE -  //
+             (size_t)(s1 > s2 ? s1 : s2);
+  if (n > N) n = N;
+
+  // Unaligned loads handle the case where the strings
+  // have mismatching alignments.
+  const v128_t *w1 = (v128_t *)s1;
+  const v128_t *w2 = (v128_t *)s2;
+  for (; n >= sizeof(v128_t); n -= sizeof(v128_t)) {
+    v128_t v1 = __tolower8x16(wasm_v128_load(w1));
+    v128_t v2 = __tolower8x16(wasm_v128_load(w2));
+
+    // Find any single bit difference.
+    if (wasm_v128_any_true(v1 ^ v2)) {
+      // The terminator may come before the difference.
+      break;
+    }
+    // We know all characters are equal.
+    // If any is a terminator the strings are equal.
+    if (!wasm_i8x16_all_true(v1)) {
+      return 0;
+    }
+    w1++;
+    w2++;
+  }
+
+  // Scalar algorithm.
+  const unsigned char *u1 = (unsigned char *)w1;
+  const unsigned char *u2 = (unsigned char *)w2;
+  while (n--) {
+    int c1 = tolower(*u1);
+    int c2 = tolower(*u2);
+    if (c1 != c2) return c1 - c2;
+    if (c1 == 0) break;
+    u1++;
+    u2++;
+  }
+  return 0;
+}
+
+#endif  // __wasm_simd128__
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // _WASM_SIMD128_STRINGS_H

sqlite3/main.c

@@ -10,12 +10,11 @@
 #include "ext/spellfix.c"
 #include "ext/uint.c"
 // Bindings
-#include "bind.c"
-#include "column.c"
 #include "func.c"
 #include "hooks.c"
 #include "pointer.c"
-#include "result.c"
+#include "stmt.c"
+#include "text.c"
 #include "time.c"
 #include "vfs.c"
 #include "vtab.c"

sqlite3/result.c

@@ -1,14 +0,0 @@
-#include <math.h>
-#include <stdlib.h>
-
-#include "sqlite3.h"
-
-void sqlite3_result_text_go(sqlite3_context *ctx, const char *zData,
-                            sqlite3_uint64 nData) {
-  sqlite3_result_text64(ctx, zData, nData, &sqlite3_free, SQLITE_UTF8);
-}
-
-void sqlite3_result_blob_go(sqlite3_context *ctx, const void *zData,
-                            sqlite3_uint64 nData) {
-  sqlite3_result_blob64(ctx, zData, nData, &sqlite3_free);
-}

sqlite3/sqlite_opt.h

@@ -4,26 +4,24 @@
 #define SQLITE_THREADSAFE 0
 #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
 #define SQLITE_OMIT_AUTOINIT
 
 // We need these:
 // #define SQLITE_DEFAULT_MEMSTATUS 0
+// #define SQLITE_MAX_EXPR_DEPTH 0
+// #define SQLITE_USE_ALLOCA
 // #define SQLITE_OMIT_DECLTYPE
 // #define SQLITE_OMIT_PROGRESS_CALLBACK
 
-// TODO add this:
-// #define SQLITE_ENABLE_API_ARMOR
-
 // Other Options
 
 #define SQLITE_ALLOW_URI_AUTHORITY
 #define SQLITE_TRUSTED_SCHEMA 0
 #define SQLITE_DEFAULT_FOREIGN_KEYS 1
+#define SQLITE_ENABLE_API_ARMOR
 #define SQLITE_ENABLE_ATOMIC_WRITE
 #define SQLITE_ENABLE_BATCH_ATOMIC_WRITE
 #define SQLITE_ENABLE_COLUMN_METADATA

sqlite3/stmt.c

@@ -2,6 +2,11 @@
 
 #include "sqlite3.h"
 
+int sqlite3_exec_go(sqlite3_stmt *stmt) {
+  while (sqlite3_step(stmt) == SQLITE_ROW);
+  return sqlite3_reset(stmt);
+}
+
 union sqlite3_data {
   sqlite3_int64 i;
   double d;
@@ -16,7 +21,7 @@ int sqlite3_columns_go(sqlite3_stmt *stmt, int nCol, char *aType,
   if (nCol != sqlite3_column_count(stmt)) {
     return SQLITE_MISUSE;
   }
-  int rc = SQLITE_OK;
+  bool check = false;
   for (int i = 0; i < nCol; ++i) {
     const void *ptr = NULL;
     switch (aType[i] = sqlite3_column_type(stmt, i)) {
@@ -36,16 +41,14 @@ int sqlite3_columns_go(sqlite3_stmt *stmt, int nCol, char *aType,
         ptr = sqlite3_column_blob(stmt, i);
         break;
     }
-    if (ptr == NULL && rc == SQLITE_OK) {
-      rc = sqlite3_errcode(sqlite3_db_handle(stmt));
-      if (rc == SQLITE_ROW || rc == SQLITE_DONE) {
-        rc = SQLITE_OK;
-      }
-    }
     aData[i].ptr = ptr;
     aData[i].len = sqlite3_column_bytes(stmt, i);
+    if (ptr == NULL) check = true;
   }
-  return rc;
+  if (check && SQLITE_NOMEM == sqlite3_errcode(sqlite3_db_handle(stmt))) {
+    return SQLITE_NOMEM;
+  }
+  return SQLITE_OK;
 }
 
 static_assert(offsetof(union sqlite3_data, i) == 0, "Unexpected offset");

sqlite3/strcasecmp.patch

@@ -0,0 +1,41 @@
+# Use strcasecmp and strncasecmp.
+--- sqlite3.c.orig
++++ sqlite3.c
+@@ -35685,35 +35685,15 @@
+   return sqlite3StrICmp(zLeft, zRight);
+ }
+ SQLITE_PRIVATE int sqlite3StrICmp(const char *zLeft, const char *zRight){
+-  unsigned char *a, *b;
+-  int c, x;
+-  a = (unsigned char *)zLeft;
+-  b = (unsigned char *)zRight;
+-  for(;;){
+-    c = *a;
+-    x = *b;
+-    if( c==x ){
+-      if( c==0 ) break;
+-    }else{
+-      c = (int)UpperToLower[c] - (int)UpperToLower[x];
+-      if( c ) break;
+-    }
+-    a++;
+-    b++;
+-  }
+-  return c;
++  return strcasecmp(zLeft, zRight);
+ }
+ SQLITE_API int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){
+-  register unsigned char *a, *b;
+   if( zLeft==0 ){
+     return zRight ? -1 : 0;
+   }else if( zRight==0 ){
+     return 1;
+   }
+-  a = (unsigned char *)zLeft;
+-  b = (unsigned char *)zRight;
+-  while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
+-  return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];
++  return strncasecmp(zLeft, zRight, N);
+ }
+ 
+ /*

sqlite3/text.c

@@ -10,4 +10,14 @@ int sqlite3_bind_text_go(sqlite3_stmt *stmt, int i, const char *zData,
 int sqlite3_bind_blob_go(sqlite3_stmt *stmt, int i, const char *zData,
                          sqlite3_uint64 nData) {
   return sqlite3_bind_blob64(stmt, i, zData, nData, &sqlite3_free);
+}
+
+void sqlite3_result_text_go(sqlite3_context *ctx, const char *zData,
+                            sqlite3_uint64 nData) {
+  sqlite3_result_text64(ctx, zData, nData, &sqlite3_free, SQLITE_UTF8);
+}
+
+void sqlite3_result_blob_go(sqlite3_context *ctx, const void *zData,
+                            sqlite3_uint64 nData) {
+  sqlite3_result_blob64(ctx, zData, nData, &sqlite3_free);
 }

sqlite3/tools.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd -P -- "$(dirname -- "$0")"
+
+ROOT=../
+
+if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" ]]; then
+  WASI_SDK="x86_64-windows"
+  BINARYEN="x86_64-windows"
+elif [[ "$OSTYPE" == "linux"* ]]; then
+  if [[ "$(uname -m)" == "x86_64" ]]; then
+    WASI_SDK="x86_64-linux"
+    BINARYEN="x86_64-linux"
+  else
+    WASI_SDK="arm64-linux"
+    BINARYEN="aarch64-linux"
+  fi
+elif [[ "$OSTYPE" == "darwin"* ]]; then
+  if [[ "$(uname -m)" == "x86_64" ]]; then
+    WASI_SDK="x86_64-macos"
+    BINARYEN="x86_64-macos"
+  else
+    WASI_SDK="arm64-macos"
+    BINARYEN="arm64-macos"
+  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"
+
+# Download tools
+mkdir -p "$ROOT/tools"
+[ -d "$ROOT/tools/wasi-sdk" ] || curl -#L "$WASI_SDK" | tar xzC "$ROOT/tools" &
+[ -d "$ROOT/tools/binaryen" ] || curl -#L "$BINARYEN" | tar xzC "$ROOT/tools" &
+wait
+
+[ -d "$ROOT/tools/wasi-sdk" ] || mv "$ROOT/tools/wasi-sdk"* "$ROOT/tools/wasi-sdk"
+[ -d "$ROOT/tools/binaryen" ] || mv "$ROOT/tools/binaryen"* "$ROOT/tools/binaryen"

sqlite3/vfs.c

@@ -137,9 +137,10 @@ sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName) {
 
   // Create a new C wrapper.
   sqlite3_vfs *head = go_vfs_list;
-  go_vfs_list = malloc(sizeof(sqlite3_vfs) + strlen(zVfsName) + 1);
+  size_t vfsNameLen = strlen(zVfsName);
+  go_vfs_list = malloc(sizeof(sqlite3_vfs) + vfsNameLen + 1);
   char *name = (char *)(go_vfs_list + 1);
-  strcpy(name, zVfsName);
+  memcpy(name, zVfsName, vfsNameLen + 1);
   *go_vfs_list = (sqlite3_vfs){
       .iVersion = 2,
       .szOsFile = sizeof(struct go_file),

sqlite3/vfs_find.patch

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

stmt.go

@@ -110,10 +110,7 @@ func (s *Stmt) Step() bool {
 		s.err = INTERRUPT
 		return false
 	}
-	return s.step()
-}
 
-func (s *Stmt) step() bool {
 	rc := res_t(s.c.call("sqlite3_step", stk_t(s.handle)))
 	switch rc {
 	case _ROW:
@@ -141,10 +138,9 @@ func (s *Stmt) Exec() error {
 	if s.c.interrupt.Err() != nil {
 		return INTERRUPT
 	}
-	// TODO: implement this in C.
-	for s.step() {
-	}
-	return s.Reset()
+	rc := res_t(s.c.call("sqlite3_exec_go", stk_t(s.handle)))
+	s.err = nil
+	return s.c.error(rc)
 }
 
 // Status monitors the performance characteristics of prepared statements.
@@ -371,11 +367,9 @@ func (s *Stmt) BindPointer(param int, ptr any) error {
 //
 // https://sqlite.org/c3ref/bind_blob.html
 func (s *Stmt) BindJSON(param int, value any) error {
-	data, err := json.Marshal(value)
-	if err != nil {
-		return err
-	}
-	return s.BindRawText(param, data)
+	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.
@@ -649,6 +643,7 @@ func (s *Stmt) ColumnValue(col int) Value {
 // [FLOAT] as float64, [NULL] as nil,
 // [TEXT] as string, and [BLOB] as []byte.
 func (s *Stmt) Columns(dest ...any) error {
+	defer s.c.arena.mark()()
 	types, ptr, err := s.columns(int64(len(dest)))
 	if err != nil {
 		return err
@@ -701,6 +696,7 @@ func (s *Stmt) Columns(dest ...any) error {
 // Any []byte are owned by SQLite and may be invalidated by
 // subsequent calls to [Stmt] methods.
 func (s *Stmt) ColumnsRaw(dest ...any) error {
+	defer s.c.arena.mark()()
 	types, ptr, err := s.columns(int64(len(dest)))
 	if err != nil {
 		return err
@@ -739,7 +735,6 @@ func (s *Stmt) ColumnsRaw(dest ...any) error {
 }
 
 func (s *Stmt) columns(count int64) ([]byte, ptr_t, error) {
-	defer s.c.arena.mark()()
 	typePtr := s.c.arena.new(count)
 	dataPtr := s.c.arena.new(count * 8)
 
@@ -754,3 +749,7 @@ 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/config_test.go

@@ -114,6 +114,7 @@ func TestConn_FileControl(t *testing.T) {
 			t.Errorf("got %v, want MISUSE", err)
 		}
 	})
+
 	t.Run("FCNTL_RESET_CACHE", func(t *testing.T) {
 		o, err := db.FileControl("", sqlite3.FCNTL_RESET_CACHE)
 		if err != nil {
@@ -237,6 +238,16 @@ func TestConn_FileControl(t *testing.T) {
 			t.Errorf("got %v, want LOCK_EXCLUSIVE", o)
 		}
 	})
+
+	t.Run("FCNTL_NULL_IO", func(t *testing.T) {
+		o, err := db.FileControl("", sqlite3.FCNTL_NULL_IO)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if o != nil {
+			t.Errorf("got %v, want nil", o)
+		}
+	})
 }
 
 func TestConn_Limit(t *testing.T) {

tests/conn_test.go

@@ -295,6 +295,17 @@ func TestConn_Filename(t *testing.T) {
 	t.Parallel()
 
 	file := filepath.Join(t.TempDir(), "test.db")
+	f, err := os.Create(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	f.Close()
+
+	file, err = filepath.EvalSymlinks(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+
 	db, err := sqlite3.Open(file)
 	if err != nil {
 		t.Fatal(err)

tests/parallel/parallel_test.go

@@ -35,7 +35,7 @@ func TestMain(m *testing.M) {
 			log.Printf("%v (%d): %s", code, code, msg)
 		}
 	})
-	m.Run()
+	os.Exit(m.Run())
 }
 
 func Test_parallel(t *testing.T) {

tests/txn_test.go

@@ -287,8 +287,9 @@ func TestConn_Transaction_busy(t *testing.T) {
 	go cancel()
 
 	_, err = db2.BeginExclusive()
-	if !errors.Is(err, sqlite3.BUSY) && !errors.Is(err, sqlite3.INTERRUPT) {
-		t.Errorf("got %v, want sqlite3.BUSY or sqlite3.INTERRUPT", err)
+	var terr interface{ Temporary() bool }
+	if !errors.As(err, &terr) || !terr.Temporary() {
+		t.Errorf("got %v, want temporary", err)
 	}
 
 	err = nil

util/sql3util/wasm/build.sh

@@ -10,11 +10,13 @@ WASI_SDK="$ROOT/tools/wasi-sdk/bin"
 trap 'rm -f sql3parse_table.tmp' EXIT
 
 "$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -g0 -Oz \
-	-Wall -Wextra -o sql3parse_table.wasm main.c \
+	-Wall -Wextra -Wno-unused-parameter -Wno-unused-function \
+	-o sql3parse_table.wasm main.c \
+	-I"$ROOT/sqlite3/libc" -I"$ROOT/sqlite3" \
 	-mexec-model=reactor \
-	-msimd128 -mmutable-globals -mmultivalue \
-	-mbulk-memory -mreference-types \
-	-mnontrapping-fptoint -msign-ext \
+	-mmutable-globals -mnontrapping-fptoint \
+	-msimd128 -mbulk-memory -msign-ext \
+	-mreference-types -mmultivalue \
 	-fno-stack-protector -fno-stack-clash-protection \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
@@ -22,7 +24,7 @@ trap 'rm -f sql3parse_table.tmp' EXIT
 
 "$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 \
-	--enable-simd --enable-mutable-globals --enable-multivalue \
-	--enable-bulk-memory --enable-reference-types \
-	--enable-nontrapping-float-to-int --enable-sign-ext
+	sql3parse_table.tmp -o sql3parse_table.wasm --low-memory-unused \
+	--enable-mutable-globals --enable-nontrapping-float-to-int \
+	--enable-simd --enable-bulk-memory --enable-sign-ext \
+	--enable-reference-types --enable-multivalue

vfs/const.go

@@ -234,6 +234,7 @@ const (
 	_FCNTL_CKSM_FILE             _FcntlOpcode = 41
 	_FCNTL_RESET_CACHE           _FcntlOpcode = 42
 	_FCNTL_NULL_IO               _FcntlOpcode = 43
+	_FCNTL_BLOCK_ON_CONNECT      _FcntlOpcode = 44
 )
 
 // https://sqlite.org/c3ref/c_shm_exclusive.html
@@ -246,6 +247,6 @@ const (
 	_SHM_EXCLUSIVE _ShmFlag = 8
 
 	_SHM_NLOCK = 8
-	_SHM_BASE  = 120
+	_SHM_BASE  = (22 + _SHM_NLOCK) * 4
 	_SHM_DMS   = _SHM_BASE + _SHM_NLOCK
 )

vfs/file.go

@@ -13,22 +13,28 @@ import (
 type vfsOS struct{}
 
 func (vfsOS) FullPathname(path string) (string, error) {
-	path, err := filepath.Abs(path)
+	link, err := evalSymlinks(path)
 	if err != nil {
 		return "", err
 	}
-	return path, testSymlinks(filepath.Dir(path))
+	full, err := filepath.Abs(link)
+	if err == nil && link != path {
+		err = _OK_SYMLINK
+	}
+	return full, err
 }
 
-func testSymlinks(path string) error {
-	p, err := filepath.EvalSymlinks(path)
+func evalSymlinks(path string) (string, error) {
+	var file string
+	_, err := os.Lstat(path)
+	if errors.Is(err, fs.ErrNotExist) {
+		path, file = filepath.Split(path)
+	}
+	path, err = filepath.EvalSymlinks(path)
 	if err != nil {
-		return err
+		return "", err
 	}
-	if p != path {
-		return _OK_SYMLINK
-	}
-	return nil
+	return filepath.Join(path, file), nil
 }
 
 func (vfsOS) Delete(path string, syncDir bool) error {

vfs/memdb/memdb.go

@@ -28,9 +28,8 @@ func (memVFS) Open(name string, flags vfs.OpenFlag) (vfs.File, vfs.OpenFlag, err
 	//
 	// We refuse to open all other file types,
 	// but returning OPEN_MEMORY means SQLite won't ask us to.
-	const types = vfs.OPEN_MAIN_DB |
-		vfs.OPEN_TEMP_DB |
-		vfs.OPEN_TEMP_JOURNAL
+	const types = vfs.OPEN_MAIN_DB | vfs.OPEN_TEMP_DB |
+		vfs.OPEN_TRANSIENT_DB | vfs.OPEN_TEMP_JOURNAL
 	if flags&types == 0 {
 		// notest // OPEN_MEMORY
 		return nil, flags, sqlite3.CANTOPEN

vfs/shm_windows.go

@@ -26,7 +26,6 @@ type vfsShm struct {
 	ptrs     []ptr_t
 	stack    [1]stk_t
 	fileLock bool
-	blocking bool
 	sync.Mutex
 }
 

vfs/tests/mptest/wasm/build.sh

@@ -9,10 +9,10 @@ WASI_SDK="$ROOT/tools/wasi-sdk/bin"
 
 "$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -g0 -O2 \
 	-o mptest.wasm main.c \
-	-I"$ROOT/sqlite3" \
-	-msimd128 -mmutable-globals -mmultivalue \
-	-mbulk-memory -mreference-types \
-	-mnontrapping-fptoint -msign-ext \
+	-I"$ROOT/sqlite3/libc" -I"$ROOT/sqlite3" \
+	-mmutable-globals -mnontrapping-fptoint \
+	-msimd128 -mbulk-memory -msign-ext \
+	-mreference-types -mmultivalue \
 	-fno-stack-protector -fno-stack-clash-protection \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
@@ -26,8 +26,8 @@ WASI_SDK="$ROOT/tools/wasi-sdk/bin"
 	$(awk '{print "-Wl,--export="$0}' exports.txt)
 
 "$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
-	mptest.wasm -o mptest.tmp \
-	--enable-simd --enable-mutable-globals --enable-multivalue \
-	--enable-bulk-memory --enable-reference-types \
-	--enable-nontrapping-float-to-int --enable-sign-ext
+	mptest.wasm -o mptest.tmp --low-memory-unused \
+	--enable-mutable-globals --enable-nontrapping-float-to-int \
+	--enable-simd --enable-bulk-memory --enable-sign-ext \
+	--enable-reference-types --enable-multivalue
 mv mptest.tmp mptest.wasm

vfs/tests/speedtest1/wasm/build.sh

@@ -9,10 +9,10 @@ WASI_SDK="$ROOT/tools/wasi-sdk/bin"
 
 "$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -g0 -O2 \
 	-o speedtest1.wasm main.c \
-	-I"$ROOT/sqlite3" \
-	-msimd128 -mmutable-globals -mmultivalue \
-	-mbulk-memory -mreference-types \
-	-mnontrapping-fptoint -msign-ext \
+	-I"$ROOT/sqlite3/libc" -I"$ROOT/sqlite3" \
+	-mmutable-globals -mnontrapping-fptoint \
+	-msimd128 -mbulk-memory -msign-ext \
+	-mreference-types -mmultivalue \
 	-fno-stack-protector -fno-stack-clash-protection \
 	-Wl,--stack-first \
 	-Wl,--import-undefined \
@@ -21,8 +21,8 @@ WASI_SDK="$ROOT/tools/wasi-sdk/bin"
 	$(awk '{print "-Wl,--export="$0}' exports.txt)
 
 "$BINARYEN/wasm-opt" -g --strip --strip-producers -c -O3 \
-	speedtest1.wasm -o speedtest1.tmp \
-	--enable-simd --enable-mutable-globals --enable-multivalue \
-	--enable-bulk-memory --enable-reference-types \
-	--enable-nontrapping-float-to-int --enable-sign-ext
+	speedtest1.wasm -o speedtest1.tmp --low-memory-unused \
+	--enable-mutable-globals --enable-nontrapping-float-to-int \
+	--enable-simd --enable-bulk-memory --enable-sign-ext \
+	--enable-reference-types --enable-multivalue
 mv speedtest1.tmp speedtest1.wasm

vfs/vfs.go

@@ -381,6 +381,10 @@ func vfsFileControlImpl(ctx context.Context, mod api.Module, file File, op _Fcnt
 			file.SetDB(ctx.Value(util.ConnKey{}))
 			return _OK
 		}
+
+	case _FCNTL_NULL_IO:
+		file.Close()
+		return _OK
 	}
 
 	return _NOTFOUND