SQLite 3.45.1.

.github/workflows/bsd.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+echo 'set -euo pipefail' > test.sh
+
+for p in $(go list ./...); do
+  dir=".${p#github.com/ncruces/go-sqlite3}"
+  name="$(basename "$p").test"
+  (cd ${dir}; GOOS=freebsd go test -c)
+  [ -f "${dir}/${name}" ] && echo "(cd ${dir}; ./${name} -test.v)" >> test.sh
+done

.github/workflows/bsd.yml

@@ -12,13 +12,20 @@ jobs:
       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: |
-          sudo pkg install -y go121
-          go121 test -v ./...
+        run: source test.sh

.github/workflows/cpu.yml

@@ -18,7 +18,7 @@ jobs:
         go-version: stable
 
     - name: Test
-      run: GOARCH=386 go test -v ./...
+      run: GOARCH=386 go test -v -short ./...
 
   test-arm:
     runs-on: ubuntu-latest
@@ -37,4 +37,20 @@ jobs:
       uses: docker/setup-qemu-action@v3
 
     - name: Test
-      run: GOARCH=arm64 go test -v ./...
+      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.sh

@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
+set -euo pipefail
 
 echo android       ; GOOS=android   GOARCH=amd64 go build .
 echo darwin        ; GOOS=darwin    GOARCH=amd64 go build .

README.md

@@ -100,20 +100,25 @@ On BSD Unixes, this module uses
 [BSD locks](https://man.freebsd.org/cgi/man.cgi?query=flock&sektion=2).
 On BSD Unixes, BSD locks are fully compatible with POSIX advisory locks.
 
-On Windows, this module uses `LockFile`, `LockFileEx`, and `UnlockFile`,
+On Windows, this module uses `LockFileEx` and `UnlockFileEx`,
 like SQLite.
 
 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.
+
 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).
-It also benefits greatly from [SQLite's](https://www.sqlite.org/testing.html) and
+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.
 
 The pure Go VFS is tested by running SQLite's

backup.go

@@ -121,7 +121,7 @@ func (b *Backup) Step(nPage int) (done bool, err error) {
 // https://sqlite.org/c3ref/backup_finish.html#sqlite3backupremaining
 func (b *Backup) Remaining() int {
 	r := b.c.call("sqlite3_backup_remaining", uint64(b.handle))
-	return int(r)
+	return int(int32(r))
 }
 
 // PageCount returns the total number of pages in the source database
@@ -130,5 +130,5 @@ func (b *Backup) Remaining() int {
 // https://sqlite.org/c3ref/backup_finish.html#sqlite3backuppagecount
 func (b *Backup) PageCount() int {
 	r := b.c.call("sqlite3_backup_pagecount", uint64(b.handle))
-	return int(r)
+	return int(int32(r))
 }

config.go

@@ -35,7 +35,7 @@ func (c *Conn) Config(op DBConfig, arg ...bool) (bool, error) {
 
 // ConfigLog sets up the error logging callback for the connection.
 //
-// https://www.sqlite.org/errlog.html
+// https://sqlite.org/errlog.html
 func (c *Conn) ConfigLog(cb func(code ExtendedErrorCode, msg string)) error {
 	var enable uint64
 	if cb != nil {
@@ -55,3 +55,49 @@ func logCallback(ctx context.Context, mod api.Module, _, iCode, zMsg uint32) {
 		c.log(xErrorCode(iCode), msg)
 	}
 }
+
+// Limit allows the size of various constructs to be
+// limited on a connection by connection basis.
+//
+// https://sqlite.org/c3ref/limit.html
+func (c *Conn) Limit(id LimitCategory, value int) int {
+	r := c.call("sqlite3_limit", uint64(c.handle), uint64(id), uint64(value))
+	return int(int32(r))
+}
+
+// SetAuthorizer registers an authorizer callback with the database connection.
+//
+// https://sqlite.org/c3ref/set_authorizer.html
+func (c *Conn) SetAuthorizer(cb func(action AuthorizerActionCode, name3rd, name4th, schema, nameInner string) AuthorizerReturnCode) error {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	r := c.call("sqlite3_set_authorizer_go", uint64(c.handle), enable)
+	if err := c.error(r); err != nil {
+		return err
+	}
+	c.authorizer = cb
+	return nil
+
+}
+
+func authorizerCallback(ctx context.Context, mod api.Module, pDB uint32, action AuthorizerActionCode, zName3rd, zName4th, zSchema, zNameInner uint32) AuthorizerReturnCode {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.authorizer != nil {
+		var name3rd, name4th, schema, nameInner string
+		if zName3rd != 0 {
+			name3rd = util.ReadString(mod, zName3rd, _MAX_NAME)
+		}
+		if zName4th != 0 {
+			name4th = util.ReadString(mod, zName4th, _MAX_NAME)
+		}
+		if zSchema != 0 {
+			schema = util.ReadString(mod, zSchema, _MAX_NAME)
+		}
+		if zNameInner != 0 {
+			nameInner = util.ReadString(mod, zNameInner, _MAX_NAME)
+		}
+		return c.authorizer(action, name3rd, name4th, schema, nameInner)
+	}
+	return AUTH_OK
+}

conn.go

@@ -4,8 +4,10 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"math"
 	"net/url"
 	"strings"
+	"time"
 
 	"github.com/ncruces/go-sqlite3/internal/util"
 	"github.com/tetratelabs/wazero/api"
@@ -18,10 +20,16 @@ import (
 type Conn struct {
 	*sqlite
 
-	interrupt context.Context
-	pending   *Stmt
-	log       func(code xErrorCode, msg string)
-	arena     arena
+	interrupt  context.Context
+	pending    *Stmt
+	busy       func(int) bool
+	log        func(xErrorCode, string)
+	collation  func(*Conn, string)
+	authorizer func(AuthorizerActionCode, string, string, string, string) AuthorizerReturnCode
+	update     func(AuthorizerActionCode, string, string, int64)
+	commit     func() bool
+	rollback   func()
+	arena      arena
 
 	handle uint32
 }
@@ -194,6 +202,32 @@ func (c *Conn) PrepareFlags(sql string, flags PrepareFlag) (stmt *Stmt, tail str
 	return stmt, tail, nil
 }
 
+// DBName returns the schema name for n-th database on the database connection.
+//
+// https://sqlite.org/c3ref/db_name.html
+func (c *Conn) DBName(n int) string {
+	r := c.call("sqlite3_db_name", uint64(c.handle), uint64(n))
+
+	ptr := uint32(r)
+	if ptr == 0 {
+		return ""
+	}
+	return util.ReadString(c.mod, ptr, _MAX_NAME)
+}
+
+// ReadOnly determines if a database is read-only.
+//
+// https://sqlite.org/c3ref/db_readonly.html
+func (c *Conn) ReadOnly(schema string) (ro bool, ok bool) {
+	var ptr uint32
+	if schema != "" {
+		defer c.arena.mark()()
+		ptr = c.arena.string(schema)
+	}
+	r := c.call("sqlite3_db_readonly", uint64(c.handle), uint64(ptr))
+	return int32(r) > 0, int32(r) < 0
+}
+
 // GetAutocommit tests the connection for auto-commit mode.
 //
 // https://sqlite.org/c3ref/get_autocommit.html
@@ -211,6 +245,14 @@ func (c *Conn) LastInsertRowID() int64 {
 	return int64(r)
 }
 
+// SetLastInsertRowID allows the application to set the value returned by
+// [Conn.LastInsertRowID].
+//
+// https://sqlite.org/c3ref/set_last_insert_rowid.html
+func (c *Conn) SetLastInsertRowID(id int64) {
+	c.call("sqlite3_set_last_insert_rowid", uint64(c.handle), uint64(id))
+}
+
 // Changes returns the number of rows modified, inserted or deleted
 // by the most recently completed INSERT, UPDATE or DELETE statement
 // on the database connection.
@@ -221,6 +263,24 @@ func (c *Conn) Changes() int64 {
 	return int64(r)
 }
 
+// TotalChanges returns the number of rows modified, inserted or deleted
+// by all INSERT, UPDATE or DELETE statements completed
+// since the database connection was opened.
+//
+// https://sqlite.org/c3ref/total_changes.html
+func (c *Conn) TotalChanges() int64 {
+	r := c.call("sqlite3_total_changes64", uint64(c.handle))
+	return int64(r)
+}
+
+// ReleaseMemory frees memory used by a database connection.
+//
+// https://sqlite.org/c3ref/db_release_memory.html
+func (c *Conn) ReleaseMemory() error {
+	r := c.call("sqlite3_db_release_memory", uint64(c.handle))
+	return c.error(r)
+}
+
 // SetInterrupt interrupts a long-running query when a context is done.
 //
 // Subsequent uses of the connection will return [INTERRUPT]
@@ -265,8 +325,8 @@ func (c *Conn) checkInterrupt() {
 	}
 }
 
-func progressCallback(ctx context.Context, mod api.Module, _ uint32) uint32 {
-	if c, ok := ctx.Value(connKey{}).(*Conn); ok {
+func progressCallback(ctx context.Context, mod api.Module, pDB uint32) uint32 {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.commit != nil {
 		if c.interrupt != nil && c.interrupt.Err() != nil {
 			return 1
 		}
@@ -274,9 +334,41 @@ func progressCallback(ctx context.Context, mod api.Module, _ uint32) uint32 {
 	return 0
 }
 
-// Pragma executes a PRAGMA statement and returns any results.
+// BusyTimeout sets a busy timeout.
 //
-// https://sqlite.org/pragma.html
+// https://sqlite.org/c3ref/busy_timeout.html
+func (c *Conn) BusyTimeout(timeout time.Duration) error {
+	ms := min((timeout+time.Millisecond-1)/time.Millisecond, math.MaxInt32)
+	r := c.call("sqlite3_busy_timeout", uint64(c.handle), uint64(ms))
+	return c.error(r)
+}
+
+// BusyHandler registers a callback to handle [BUSY] errors.
+//
+// https://sqlite.org/c3ref/busy_handler.html
+func (c *Conn) BusyHandler(cb func(count int) (retry bool)) error {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	r := c.call("sqlite3_busy_handler_go", uint64(c.handle), enable)
+	if err := c.error(r); err != nil {
+		return err
+	}
+	c.busy = cb
+	return nil
+}
+
+func busyCallback(ctx context.Context, mod api.Module, pDB, count uint32) uint32 {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.busy != nil {
+		if retry := c.busy(int(count)); retry {
+			return 1
+		}
+	}
+	return 0
+}
+
+// Deprecated: executes a PRAGMA statement and returns results.
 func (c *Conn) Pragma(str string) ([]string, error) {
 	stmt, _, err := c.Prepare(`PRAGMA ` + str)
 	if err != nil {

const.go

@@ -229,6 +229,93 @@ const (
 	DBCONFIG_REVERSE_SCANORDER     DBConfig = 1019
 )
 
+// LimitCategory are the available run-time limit categories.
+//
+// https://sqlite.org/c3ref/c_limit_attached.html
+type LimitCategory uint32
+
+const (
+	LIMIT_LENGTH              LimitCategory = 0
+	LIMIT_SQL_LENGTH          LimitCategory = 1
+	LIMIT_COLUMN              LimitCategory = 2
+	LIMIT_EXPR_DEPTH          LimitCategory = 3
+	LIMIT_COMPOUND_SELECT     LimitCategory = 4
+	LIMIT_VDBE_OP             LimitCategory = 5
+	LIMIT_FUNCTION_ARG        LimitCategory = 6
+	LIMIT_ATTACHED            LimitCategory = 7
+	LIMIT_LIKE_PATTERN_LENGTH LimitCategory = 8
+	LIMIT_VARIABLE_NUMBER     LimitCategory = 9
+	LIMIT_TRIGGER_DEPTH       LimitCategory = 10
+	LIMIT_WORKER_THREADS      LimitCategory = 11
+)
+
+// AuthorizerActionCode are the integer action codes
+// that the authorizer callback may be passed.
+//
+// https://sqlite.org/c3ref/c_alter_table.html
+type AuthorizerActionCode uint32
+
+const (
+	/************************************************ 3rd ************ 4th ***********/
+	CREATE_INDEX        AuthorizerActionCode = 1  /* Index Name      Table Name      */
+	CREATE_TABLE        AuthorizerActionCode = 2  /* Table Name      NULL            */
+	CREATE_TEMP_INDEX   AuthorizerActionCode = 3  /* Index Name      Table Name      */
+	CREATE_TEMP_TABLE   AuthorizerActionCode = 4  /* Table Name      NULL            */
+	CREATE_TEMP_TRIGGER AuthorizerActionCode = 5  /* Trigger Name    Table Name      */
+	CREATE_TEMP_VIEW    AuthorizerActionCode = 6  /* View Name       NULL            */
+	CREATE_TRIGGER      AuthorizerActionCode = 7  /* Trigger Name    Table Name      */
+	CREATE_VIEW         AuthorizerActionCode = 8  /* View Name       NULL            */
+	DELETE              AuthorizerActionCode = 9  /* Table Name      NULL            */
+	DROP_INDEX          AuthorizerActionCode = 10 /* Index Name      Table Name      */
+	DROP_TABLE          AuthorizerActionCode = 11 /* Table Name      NULL            */
+	DROP_TEMP_INDEX     AuthorizerActionCode = 12 /* Index Name      Table Name      */
+	DROP_TEMP_TABLE     AuthorizerActionCode = 13 /* Table Name      NULL            */
+	DROP_TEMP_TRIGGER   AuthorizerActionCode = 14 /* Trigger Name    Table Name      */
+	DROP_TEMP_VIEW      AuthorizerActionCode = 15 /* View Name       NULL            */
+	DROP_TRIGGER        AuthorizerActionCode = 16 /* Trigger Name    Table Name      */
+	DROP_VIEW           AuthorizerActionCode = 17 /* View Name       NULL            */
+	INSERT              AuthorizerActionCode = 18 /* Table Name      NULL            */
+	PRAGMA              AuthorizerActionCode = 19 /* Pragma Name     1st arg or NULL */
+	READ                AuthorizerActionCode = 20 /* Table Name      Column Name     */
+	SELECT              AuthorizerActionCode = 21 /* NULL            NULL            */
+	TRANSACTION         AuthorizerActionCode = 22 /* Operation       NULL            */
+	UPDATE              AuthorizerActionCode = 23 /* Table Name      Column Name     */
+	ATTACH              AuthorizerActionCode = 24 /* Filename        NULL            */
+	DETACH              AuthorizerActionCode = 25 /* Database Name   NULL            */
+	ALTER_TABLE         AuthorizerActionCode = 26 /* Database Name   Table Name      */
+	REINDEX             AuthorizerActionCode = 27 /* Index Name      NULL            */
+	ANALYZE             AuthorizerActionCode = 28 /* Table Name      NULL            */
+	CREATE_VTABLE       AuthorizerActionCode = 29 /* Table Name      Module Name     */
+	DROP_VTABLE         AuthorizerActionCode = 30 /* Table Name      Module Name     */
+	FUNCTION            AuthorizerActionCode = 31 /* NULL            Function Name   */
+	SAVEPOINT           AuthorizerActionCode = 32 /* Operation       Savepoint Name  */
+	COPY                AuthorizerActionCode = 0  /* No longer used */
+	RECURSIVE           AuthorizerActionCode = 33 /* NULL            NULL            */
+)
+
+// AuthorizerReturnCode are the integer codes
+// that the authorizer callback may return.
+//
+// https://sqlite.org/c3ref/c_deny.html
+type AuthorizerReturnCode uint32
+
+const (
+	AUTH_OK     AuthorizerReturnCode = 0
+	AUTH_DENY   AuthorizerReturnCode = 1 /* Abort the SQL statement with an error */
+	AUTH_IGNORE AuthorizerReturnCode = 2 /* Don't allow access, but don't generate an error */
+)
+
+// TxnState are the allowed return values from [Conn.TxnState].
+//
+// https://sqlite.org/c3ref/c_txn_none.html
+type TxnState uint32
+
+const (
+	TXN_NONE  TxnState = 0
+	TXN_READ  TxnState = 1
+	TXN_WRITE TxnState = 2
+)
+
 // Datatype is a fundamental datatype of SQLite.
 //
 // https://sqlite.org/c3ref/c_blob.html

context.go

@@ -222,7 +222,7 @@ func (ctx Context) ResultError(err error) {
 // VTabNoChange may return true if a column is being fetched as part
 // of an update during which the column value will not change.
 //
-// https://www.sqlite.org/c3ref/vtab_nochange.html
+// https://sqlite.org/c3ref/vtab_nochange.html
 func (ctx Context) VTabNoChange() bool {
 	r := ctx.c.call("sqlite3_vtab_nochange", uint64(ctx.handle))
 	return r != 0

driver/driver.go

@@ -170,7 +170,7 @@ func (n *connector) Connect(ctx context.Context) (_ driver.Conn, err error) {
 	defer c.Conn.SetInterrupt(old)
 
 	if !n.pragmas {
-		err = c.Conn.Exec(`PRAGMA busy_timeout=60000`)
+		err = c.Conn.BusyTimeout(60 * time.Second)
 		if err != nil {
 			return nil, err
 		}
@@ -538,8 +538,13 @@ func (r *rows) Next(dest []driver.Value) error {
 	for i := range dest {
 		if t, ok := r.decodeTime(i, dest[i]); ok {
 			dest[i] = t
-		} else if s, ok := dest[i].(string); ok {
-			dest[i] = stringOrTime(s)
+			continue
+		}
+		if s, ok := dest[i].(string); ok {
+			t, ok := maybeTime(s)
+			if ok {
+				dest[i] = t
+			}
 		}
 	}
 	return err

driver/time.go

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

driver/time_test.go

@@ -22,26 +22,18 @@ func Fuzz_stringOrTime_1(f *testing.F) {
 	f.Add("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.")
 
 	f.Fuzz(func(t *testing.T, str string) {
-		value := stringOrTime(str)
-
-		switch v := value.(type) {
-		case time.Time:
+		v, ok := maybeTime(str)
+		if ok {
 			// Make sure times round-trip to the same string:
 			// https://pkg.go.dev/database/sql#Rows.Scan
 			if v.Format(time.RFC3339Nano) != str {
 				t.Fatalf("did not round-trip: %q", str)
 			}
-		case string:
-			if v != str {
-				t.Fatalf("did not round-trip: %q", str)
-			}
-
+		} else {
 			date, err := time.Parse(time.RFC3339Nano, str)
 			if err == nil && date.Format(time.RFC3339Nano) == str {
 				t.Fatalf("would round-trip: %q", str)
 			}
-		default:
-			t.Fatalf("invalid type %T: %q", v, str)
 		}
 	})
 }
@@ -59,10 +51,8 @@ func Fuzz_stringOrTime_2(f *testing.F) {
 	f.Add(int64(-763421161058), int64(222_222_222)) // twosday, year 22222BC
 
 	checkTime := func(t testing.TB, date time.Time) {
-		value := stringOrTime(date.Format(time.RFC3339Nano))
-
-		switch v := value.(type) {
-		case time.Time:
+		v, ok := maybeTime(date.Format(time.RFC3339Nano))
+		if ok {
 			// Make sure times round-trip to the same time:
 			if !v.Equal(date) {
 				t.Fatalf("did not round-trip: %v", date)
@@ -73,10 +63,8 @@ func Fuzz_stringOrTime_2(f *testing.F) {
 			if off1 != off2 {
 				t.Fatalf("did not round-trip: %v", date)
 			}
-		case string:
+		} else {
 			t.Fatalf("was not recovered: %v", date)
-		default:
-			t.Fatalf("invalid type %T: %v", v, date)
 		}
 	}
 

embed/README.md

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

embed/exports.txt

@@ -1,7 +1,6 @@
 free
 malloc
 malloc_destructor
-sqlite3_aggregate_context
 sqlite3_anycollseq_init
 sqlite3_backup_finish
 sqlite3_backup_init
@@ -25,10 +24,13 @@ sqlite3_blob_open
 sqlite3_blob_read
 sqlite3_blob_reopen
 sqlite3_blob_write
+sqlite3_busy_handler_go
+sqlite3_busy_timeout
 sqlite3_changes64
 sqlite3_clear_bindings
 sqlite3_close
 sqlite3_close_v2
+sqlite3_collation_needed_go
 sqlite3_column_blob
 sqlite3_column_bytes
 sqlite3_column_count
@@ -40,6 +42,7 @@ sqlite3_column_text
 sqlite3_column_type
 sqlite3_column_value
 sqlite3_columns_go
+sqlite3_commit_hook_go
 sqlite3_config_log_go
 sqlite3_create_aggregate_function_go
 sqlite3_create_collation_go
@@ -47,6 +50,9 @@ sqlite3_create_function_go
 sqlite3_create_module_go
 sqlite3_create_window_function_go
 sqlite3_db_config
+sqlite3_db_name
+sqlite3_db_readonly
+sqlite3_db_release_memory
 sqlite3_declare_vtab
 sqlite3_errcode
 sqlite3_errmsg
@@ -58,6 +64,7 @@ sqlite3_get_autocommit
 sqlite3_get_auxdata
 sqlite3_interrupt
 sqlite3_last_insert_rowid
+sqlite3_limit
 sqlite3_open_v2
 sqlite3_overload_function
 sqlite3_prepare_v3
@@ -75,14 +82,19 @@ sqlite3_result_pointer_go
 sqlite3_result_text64
 sqlite3_result_value
 sqlite3_result_zeroblob64
+sqlite3_rollback_hook_go
+sqlite3_set_authorizer_go
 sqlite3_set_auxdata_go
+sqlite3_set_last_insert_rowid
 sqlite3_step
 sqlite3_stmt_busy
 sqlite3_stmt_readonly
 sqlite3_stmt_status
+sqlite3_total_changes64
+sqlite3_txn_state
+sqlite3_update_hook_go
 sqlite3_uri_key
 sqlite3_uri_parameter
-sqlite3_user_data
 sqlite3_value_blob
 sqlite3_value_bytes
 sqlite3_value_double

ext/blobio/blob.go

@@ -30,9 +30,9 @@ import (
 //
 // https://sqlite.org/c3ref/blob.html
 func Register(db *sqlite3.Conn) {
-	db.CreateFunction("readblob", 6, sqlite3.DIRECTONLY, readblob)
-	db.CreateFunction("writeblob", 6, sqlite3.DIRECTONLY, writeblob)
-	db.CreateFunction("openblob", -1, sqlite3.DIRECTONLY, openblob)
+	db.CreateFunction("readblob", 6, 0, readblob)
+	db.CreateFunction("writeblob", 6, 0, writeblob)
+	db.CreateFunction("openblob", -1, 0, openblob)
 }
 
 // OpenCallback is the type for the openblob callback.

ext/stats/stats.go

@@ -17,6 +17,7 @@
 //   - regr_count: count non-null pairs of variables
 //   - regr_slope: slope of the least-squares-fit linear equation
 //   - regr_intercept: y-intercept of the least-squares-fit linear equation
+//   - regr_json: all regr stats in a JSON object
 //
 // These join the [Built-in Aggregate Functions]:
 //   - count: count rows/values
@@ -52,6 +53,7 @@ func Register(db *sqlite3.Conn) {
 	db.CreateWindowFunction("regr_slope", 2, flags, newCovariance(regr_slope))
 	db.CreateWindowFunction("regr_intercept", 2, flags, newCovariance(regr_intercept))
 	db.CreateWindowFunction("regr_count", 2, flags, newCovariance(regr_count))
+	db.CreateWindowFunction("regr_json", 2, flags, newCovariance(regr_json))
 }
 
 const (
@@ -69,6 +71,7 @@ const (
 	regr_slope
 	regr_intercept
 	regr_count
+	regr_json
 )
 
 func newVariance(kind int) func() sqlite3.AggregateFunction {
@@ -144,6 +147,9 @@ func (fn *covariance) Value(ctx sqlite3.Context) {
 	case regr_count:
 		ctx.ResultInt64(fn.regr_count())
 		return
+	case regr_json:
+		ctx.ResultText(fn.regr_json())
+		return
 	}
 	ctx.ResultFloat(r)
 }

ext/stats/stats_test.go

@@ -107,7 +107,7 @@ func TestRegister_covariance(t *testing.T) {
 		regr_avgy(y, x), regr_avgx(y, x),
 		regr_syy(y, x), regr_sxx(y, x), regr_sxy(y, x),
 		regr_slope(y, x), regr_intercept(y, x), regr_r2(y, x),
-		regr_count(y, x)
+		regr_count(y, x), regr_json(y, x)
 		FROM data`)
 	if err != nil {
 		t.Fatal(err)
@@ -151,6 +151,12 @@ func TestRegister_covariance(t *testing.T) {
 		if got := stmt.ColumnInt(11); got != 5 {
 			t.Errorf("got %v, want 5", got)
 		}
+		var a map[string]float64
+		if err := stmt.ColumnJSON(12, &a); err != nil {
+			t.Error(err)
+		} else if got := a["count"]; got != 5 {
+			t.Errorf("got %v, want 5", got)
+		}
 	}
 
 	{

ext/stats/welford.go

@@ -1,6 +1,10 @@
 package stats
 
-import "math"
+import (
+	"math"
+	"strconv"
+	"strings"
+)
 
 // Welford's algorithm with Kahan summation:
 // https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm
@@ -108,6 +112,32 @@ func (w welford2) regr_r2() float64 {
 	return w.cov.hi * w.cov.hi / (w.m2y.hi * w.m2x.hi)
 }
 
+func (w welford2) regr_json() string {
+	var json strings.Builder
+	var num [32]byte
+	json.Grow(128)
+	json.WriteString(`{"count":`)
+	json.Write(strconv.AppendInt(num[:0], w.regr_count(), 10))
+	json.WriteString(`,"avgy":`)
+	json.Write(strconv.AppendFloat(num[:0], w.regr_avgy(), 'g', -1, 64))
+	json.WriteString(`,"avgx":`)
+	json.Write(strconv.AppendFloat(num[:0], w.regr_avgx(), 'g', -1, 64))
+	json.WriteString(`,"syy":`)
+	json.Write(strconv.AppendFloat(num[:0], w.regr_syy(), 'g', -1, 64))
+	json.WriteString(`,"sxx":`)
+	json.Write(strconv.AppendFloat(num[:0], w.regr_sxx(), 'g', -1, 64))
+	json.WriteString(`,"sxy":`)
+	json.Write(strconv.AppendFloat(num[:0], w.regr_sxy(), 'g', -1, 64))
+	json.WriteString(`,"slope":`)
+	json.Write(strconv.AppendFloat(num[:0], w.regr_slope(), 'g', -1, 64))
+	json.WriteString(`,"intercept":`)
+	json.Write(strconv.AppendFloat(num[:0], w.regr_intercept(), 'g', -1, 64))
+	json.WriteString(`,"r2":`)
+	json.Write(strconv.AppendFloat(num[:0], w.regr_r2(), 'g', -1, 64))
+	json.WriteByte('}')
+	return json.String()
+}
+
 func (w *welford2) enqueue(y, x float64) {
 	w.n++
 	d1y := y - w.m1y.hi - w.m1y.lo

func.go

@@ -8,8 +8,25 @@ import (
 	"github.com/tetratelabs/wazero/api"
 )
 
-// AnyCollationNeeded registers a fake collating function
-// for any unknown collating sequence.
+// CollationNeeded registers a callback to be invoked
+// whenever an unknown collation sequence is required.
+//
+// https://sqlite.org/c3ref/collation_needed.html
+func (c *Conn) CollationNeeded(cb func(db *Conn, name string)) error {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	r := c.call("sqlite3_collation_needed_go", uint64(c.handle), enable)
+	if err := c.error(r); err != nil {
+		return err
+	}
+	c.collation = cb
+	return nil
+}
+
+// AnyCollationNeeded uses [Conn.CollationNeeded] to register
+// a fake collating function for any unknown collating sequence.
 // The fake collating function works like BINARY.
 //
 // This can be used to load schemas that contain
@@ -106,6 +123,13 @@ func destroyCallback(ctx context.Context, mod api.Module, pApp uint32) {
 	util.DelHandle(ctx, pApp)
 }
 
+func collationCallback(ctx context.Context, mod api.Module, pArg, pDB, eTextRep, zName uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.collation != nil {
+		name := util.ReadString(mod, zName, _MAX_NAME)
+		c.collation(c, name)
+	}
+}
+
 func compareCallback(ctx context.Context, mod api.Module, pApp, nKey1, pKey1, nKey2, pKey2 uint32) uint32 {
 	fn := util.GetHandle(ctx, pApp).(func(a, b []byte) int)
 	return uint32(fn(util.View(mod, pKey1, uint64(nKey1)), util.View(mod, pKey2, uint64(nKey2))))

func_test.go

@@ -6,11 +6,9 @@ import (
 	"log"
 	"regexp"
 
-	"golang.org/x/text/collate"
-	"golang.org/x/text/language"
-
 	"github.com/ncruces/go-sqlite3"
 	_ "github.com/ncruces/go-sqlite3/embed"
+	"github.com/ncruces/go-sqlite3/ext/unicode"
 )
 
 func ExampleConn_CreateCollation() {
@@ -30,12 +28,17 @@ func ExampleConn_CreateCollation() {
 		log.Fatal(err)
 	}
 
-	err = db.CreateCollation("french", collate.New(language.French).Compare)
+	err = db.CollationNeeded(func(db *sqlite3.Conn, name string) {
+		err := unicode.RegisterCollation(db, name, name)
+		if err != nil {
+			log.Fatal(err)
+		}
+	})
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	stmt, _, err := db.Prepare(`SELECT word FROM words ORDER BY word COLLATE french`)
+	stmt, _, err := db.Prepare(`SELECT word FROM words ORDER BY word COLLATE fr_FR`)
 	if err != nil {
 		log.Fatal(err)
 	}

gormlite/go.mod

@@ -3,14 +3,14 @@ module github.com/ncruces/go-sqlite3/gormlite
 go 1.21
 
 require (
-	github.com/ncruces/go-sqlite3 v0.11.0
-	gorm.io/gorm v1.25.5
+	github.com/ncruces/go-sqlite3 v0.12.1
+	gorm.io/gorm v1.25.6
 )
 
 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.5.0 // indirect
-	golang.org/x/sys v0.15.0 // indirect
+	github.com/tetratelabs/wazero v1.6.0 // indirect
+	golang.org/x/sys v0.16.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.11.0 h1:PDjs8Ve2Z0GWmHyKQHGUyG78grCXKhiHCUZQI8CqXO8=
-github.com/ncruces/go-sqlite3 v0.11.0/go.mod h1:zaYJ6xP+EQiWJCa3nd3h28cD8DuSIcIqh+LrJMrBN9k=
+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/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M=
 github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g=
-github.com/tetratelabs/wazero v1.5.0 h1:Yz3fZHivfDiZFUXnWMPUoiW7s8tC1sjdBtlJn08qYa0=
-github.com/tetratelabs/wazero v1.5.0/go.mod h1:0U0G41+ochRKoPKCJlh0jMg1CHkyfK8kDqiirMmKY8A=
-golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=
-golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+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=
 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.5 h1:zR9lOiiYf09VNh5Q1gphfyia1JpiClIWG9hQaxB/mls=
-gorm.io/gorm v1.25.5/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
+gorm.io/gorm v1.25.6 h1:V92+vVda1wEISSOMtodHVRcUIOPYa2tgQtyF+DfFx+A=
+gorm.io/gorm v1.25.6/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=

gormlite/sqlite.go

@@ -2,7 +2,6 @@
 package gormlite
 
 import (
-	"context"
 	"database/sql"
 	"strconv"
 
@@ -46,23 +45,12 @@ func (dialector _Dialector) Initialize(db *gorm.DB) (err error) {
 		db.ConnPool = conn
 	}
 
-	var version string
-	if err := db.ConnPool.QueryRowContext(context.Background(), "select sqlite_version()").Scan(&version); err != nil {
-		return err
-	}
-	// https://sqlite.org/releaselog/3_35_0.html
-	if compareVersion(version, "3.35.0") >= 0 {
-		callbacks.RegisterDefaultCallbacks(db, &callbacks.Config{
-			CreateClauses:        []string{"INSERT", "VALUES", "ON CONFLICT", "RETURNING"},
-			UpdateClauses:        []string{"UPDATE", "SET", "FROM", "WHERE", "RETURNING"},
-			DeleteClauses:        []string{"DELETE", "FROM", "WHERE", "RETURNING"},
-			LastInsertIDReversed: true,
-		})
-	} else {
-		callbacks.RegisterDefaultCallbacks(db, &callbacks.Config{
-			LastInsertIDReversed: true,
-		})
-	}
+	callbacks.RegisterDefaultCallbacks(db, &callbacks.Config{
+		CreateClauses:        []string{"INSERT", "VALUES", "ON CONFLICT", "RETURNING"},
+		UpdateClauses:        []string{"UPDATE", "SET", "FROM", "WHERE", "RETURNING"},
+		DeleteClauses:        []string{"DELETE", "FROM", "WHERE", "RETURNING"},
+		LastInsertIDReversed: true,
+	})
 
 	for k, v := range dialector.ClauseBuilders() {
 		db.ClauseBuilders[k] = v
@@ -231,27 +219,3 @@ func (dialectopr _Dialector) RollbackTo(tx *gorm.DB, name string) error {
 	tx.Exec("ROLLBACK TO SAVEPOINT " + name)
 	return nil
 }
-
-func compareVersion(version1, version2 string) int {
-	n, m := len(version1), len(version2)
-	i, j := 0, 0
-	for i < n || j < m {
-		x := 0
-		for ; i < n && version1[i] != '.'; i++ {
-			x = x*10 + int(version1[i]-'0')
-		}
-		i++
-		y := 0
-		for ; j < m && version2[j] != '.'; j++ {
-			y = y*10 + int(version2[j]-'0')
-		}
-		j++
-		if x > y {
-			return 1
-		}
-		if x < y {
-			return -1
-		}
-	}
-	return 0
-}

gormlite/test.sh

@@ -6,7 +6,7 @@ cd -P -- "$(dirname -- "$0")"
 go test
 
 rm -rf gorm/ tests/
-git clone --filter=blob:none https://github.com/go-gorm/gorm.git
+git clone --branch v1.25.6 --filter=blob:none https://github.com/go-gorm/gorm.git
 mv gorm/tests tests
 rm -rf gorm/
 

internal/util/func.go

@@ -75,6 +75,19 @@ func ExportFuncVIIIII[T0, T1, T2, T3, T4 i32](mod wazero.HostModuleBuilder, name
 		Export(name)
 }
 
+type funcVIIIIJ[T0, T1, T2, T3 i32, T4 i64] func(context.Context, api.Module, T0, T1, T2, T3, T4)
+
+func (fn funcVIIIIJ[T0, T1, T2, T3, T4]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3]), T4(stack[4]))
+}
+
+func ExportFuncVIIIIJ[T0, T1, T2, T3 i32, T4 i64](mod wazero.HostModuleBuilder, name string, fn func(context.Context, api.Module, T0, T1, T2, T3, T4)) {
+	mod.NewFunctionBuilder().
+		WithGoModuleFunction(funcVIIIIJ[T0, T1, T2, T3, T4](fn),
+			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI64}, nil).
+		Export(name)
+}
+
 type funcII[TR, T0 i32] func(context.Context, api.Module, T0) TR
 
 func (fn funcII[TR, T0]) Call(ctx context.Context, mod api.Module, stack []uint64) {
@@ -140,6 +153,19 @@ func ExportFuncIIIIII[TR, T0, T1, T2, T3, T4 i32](mod wazero.HostModuleBuilder,
 		Export(name)
 }
 
+type funcIIIIIII[TR, T0, T1, T2, T3, T4, T5 i32] func(context.Context, api.Module, T0, T1, T2, T3, T4, T5) TR
+
+func (fn funcIIIIIII[TR, T0, T1, T2, T3, T4, T5]) Call(ctx context.Context, mod api.Module, stack []uint64) {
+	stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3]), T4(stack[4]), T5(stack[5])))
+}
+
+func ExportFuncIIIIIII[TR, T0, T1, T2, T3, T4, T5 i32](mod wazero.HostModuleBuilder, name string, fn func(context.Context, api.Module, T0, T1, T2, T3, T4, T5) TR) {
+	mod.NewFunctionBuilder().
+		WithGoModuleFunction(funcIIIIIII[TR, T0, T1, T2, T3, T4, T5](fn),
+			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32}, []api.ValueType{api.ValueTypeI32}).
+		Export(name)
+}
+
 type funcIIIIJ[TR, T0, T1, T2 i32, T3 i64] func(context.Context, api.Module, T0, T1, T2, T3) TR
 
 func (fn funcIIIIJ[TR, T0, T1, T2, T3]) Call(ctx context.Context, mod api.Module, stack []uint64) {

sqlite.go

@@ -289,7 +289,12 @@ func (a *arena) string(s string) uint32 {
 }
 
 func exportCallbacks(env wazero.HostModuleBuilder) wazero.HostModuleBuilder {
-	util.ExportFuncII(env, "go_progress", progressCallback)
+	util.ExportFuncIII(env, "go_busy_handler", busyCallback)
+	util.ExportFuncII(env, "go_progress_handler", progressCallback)
+	util.ExportFuncII(env, "go_commit_hook", commitCallback)
+	util.ExportFuncVI(env, "go_rollback_hook", rollbackCallback)
+	util.ExportFuncVIIIIJ(env, "go_update_hook", updateCallback)
+	util.ExportFuncIIIIIII(env, "go_authorizer", authorizerCallback)
 	util.ExportFuncVIII(env, "go_log", logCallback)
 	util.ExportFuncVI(env, "go_destroy", destroyCallback)
 	util.ExportFuncVIIII(env, "go_func", funcCallback)
@@ -297,9 +302,10 @@ func exportCallbacks(env wazero.HostModuleBuilder) wazero.HostModuleBuilder {
 	util.ExportFuncVIII(env, "go_final", finalCallback)
 	util.ExportFuncVII(env, "go_value", valueCallback)
 	util.ExportFuncVIIII(env, "go_inverse", inverseCallback)
+	util.ExportFuncVIIII(env, "go_collation_needed", collationCallback)
 	util.ExportFuncIIIIII(env, "go_compare", compareCallback)
-	util.ExportFuncIIIIII(env, "go_vtab_create", vtabModuleCallback(0))
-	util.ExportFuncIIIIII(env, "go_vtab_connect", vtabModuleCallback(1))
+	util.ExportFuncIIIIII(env, "go_vtab_create", vtabModuleCallback(xCreate))
+	util.ExportFuncIIIIII(env, "go_vtab_connect", vtabModuleCallback(xConnect))
 	util.ExportFuncII(env, "go_vtab_disconnect", vtabDisconnectCallback)
 	util.ExportFuncII(env, "go_vtab_destroy", vtabDestroyCallback)
 	util.ExportFuncIII(env, "go_vtab_best_index", vtabBestIndexCallback)

sqlite3/download.sh

@@ -3,7 +3,7 @@ set -euo pipefail
 
 cd -P -- "$(dirname -- "$0")"
 
-curl -#OL "https://sqlite.org/2024/sqlite-amalgamation-3450000.zip"
+curl -#OL "https://sqlite.org/2024/sqlite-amalgamation-3450100.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.0/ext/misc/anycollseq.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.0/ext/misc/base64.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.0/ext/misc/decimal.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.0/ext/misc/ieee754.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.0/ext/misc/regexp.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.0/ext/misc/series.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.0/ext/misc/uint.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.0/ext/misc/uuid.c"
+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"
 cd ~-
 
 cd ../vfs/tests/mptest/testdata/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.0/mptest/mptest.c"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.0/mptest/config01.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.0/mptest/config02.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.0/mptest/crash01.test"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.0/mptest/crash02.subtest"
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.0/mptest/multiwrite01.test"
+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"
 cd ~-
 
 cd ../vfs/tests/speedtest1/testdata/
-curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.0/test/speedtest1.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.45.1/test/speedtest1.c"
 cd ~-

sqlite3/func.c

@@ -1,8 +1,11 @@
+#include <stdbool.h>
 #include <stddef.h>
 
 #include "include.h"
 #include "sqlite3.h"
 
+void go_collation_needed(void *, sqlite3 *, int, const char *);
+
 int go_compare(go_handle, int, const void *, int, const void *);
 
 void go_func(sqlite3_context *, go_handle, int, sqlite3_value **);
@@ -44,6 +47,11 @@ void go_inverse_wrapper(sqlite3_context *ctx, int nArg, sqlite3_value **pArg) {
   go_inverse(ctx, *agg, nArg, pArg);
 }
 
+int sqlite3_collation_needed_go(sqlite3 *db, bool enable) {
+  return sqlite3_collation_needed(db, /*arg=*/NULL,
+                                  enable ? go_collation_needed : NULL);
+}
+
 int sqlite3_create_collation_go(sqlite3 *db, const char *name, go_handle app) {
   int rc = sqlite3_create_collation_v2(db, name, SQLITE_UTF8, app, go_compare,
                                        go_destroy);

sqlite3/hooks.c

@@ -0,0 +1,44 @@
+#include <stdbool.h>
+
+#include "sqlite3.h"
+
+int go_progress_handler(void *);
+int go_busy_handler(void *, int);
+
+int go_commit_hook(void *);
+void go_rollback_hook(void *);
+void go_update_hook(void *, int, char const *, char const *, sqlite3_int64);
+
+int go_authorizer(void *, int, const char *, const char *, const char *,
+                  const char *);
+
+void go_log(void *, int, const char *);
+
+void sqlite3_progress_handler_go(sqlite3 *db, int n) {
+  sqlite3_progress_handler(db, n, go_progress_handler, /*arg=*/db);
+}
+
+int sqlite3_busy_handler_go(sqlite3 *db, bool enable) {
+  return sqlite3_busy_handler(db, enable ? go_busy_handler : NULL, /*arg=*/db);
+}
+
+void sqlite3_commit_hook_go(sqlite3 *db, bool enable) {
+  sqlite3_commit_hook(db, enable ? go_commit_hook : NULL, /*arg=*/db);
+}
+
+void sqlite3_rollback_hook_go(sqlite3 *db, bool enable) {
+  sqlite3_rollback_hook(db, enable ? go_rollback_hook : NULL, /*arg=*/db);
+}
+
+void sqlite3_update_hook_go(sqlite3 *db, bool enable) {
+  sqlite3_update_hook(db, enable ? go_update_hook : NULL, /*arg=*/db);
+}
+
+int sqlite3_set_authorizer_go(sqlite3 *db, bool enable) {
+  return sqlite3_set_authorizer(db, enable ? go_authorizer : NULL, /*arg=*/db);
+}
+
+int sqlite3_config_log_go(bool enable) {
+  return sqlite3_config(SQLITE_CONFIG_LOG, enable ? go_log : NULL,
+                        /*arg=*/NULL);
+}

sqlite3/isoweek.patch

@@ -1,34 +1,185 @@
-# ISO week date specifiers.
-# https://sqlite.org/forum/forumpost/73d99e4497e8e6a7
+# ISO week date specifiers, backport from 3.46.
 --- sqlite3.c.orig
 +++ sqlite3.c
-@@ -1373,6 +1373,29 @@ static void strftimeFunc(
-         sqlite3_str_appendchar(&sRes, 1, 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 'V':  /* Fall thru */
-+      case 'G': {
+-      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;
-+        computeJD(&y);
++        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;
-+        /* Adjust date to Thursday this week:
-+           The number in parentheses is 0 for Monday, 3 for Thursday */
-+        y.iJD += (3 - (((y.iJD+43200000)/86400000) % 7))*86400000;
 +        computeYMD(&y);
-+        if( cf=='G' ){
-+          sqlite3_str_appendf(&sRes,"%04d",y.Y);
++        if( cf=='g' ){
++          sqlite3_str_appendf(&sRes, "%02d", y.Y%100);
 +        }else{
-+          int nDay;             /* Number of days since 1st day of year */
-+          i64 tJD = y.iJD;
-+          y.validJD = 0;
-+          y.M = 1;
-+          y.D = 1;
-+          computeJD(&y);
-+          nDay = (int)((tJD-y.iJD+43200000)/86400000);
-+          sqlite3_str_appendf(&sRes,"%02d",nDay/7+1);
++          sqlite3_str_appendf(&sRes, "%04d", y.Y);
 +        }
 +        break;
 +      }
-       case 'Y': {
-         sqlite3_str_appendf(&sRes,"%04d",x.Y);
+       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/locking_mode.patch

@@ -1,7 +1,7 @@
 # Use exclusive locking mode for WAL databases with v1 VFSes.
 --- sqlite3.c.orig
 +++ sqlite3.c
-@@ -63210,7 +63210,9 @@
+@@ -64209,7 +64209,9 @@
  SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager){
    const sqlite3_io_methods *pMethods = pPager->fd->pMethods;
    if( pPager->noLock ) return 0;

sqlite3/log.c

@@ -1,9 +0,0 @@
-#include <stdbool.h>
-
-#include "sqlite3.h"
-
-void go_log(void *, int, const char *);
-
-int sqlite3_config_log_go(bool enable) {
-  return sqlite3_config(SQLITE_CONFIG_LOG, enable ? go_log : NULL, NULL);
-}

sqlite3/main.c

@@ -12,9 +12,8 @@
 // Bindings
 #include "column.c"
 #include "func.c"
-#include "log.c"
+#include "hooks.c"
 #include "pointer.c"
-#include "progress.c"
 #include "time.c"
 #include "vfs.c"
 #include "vtab.c"

sqlite3/progress.c

@@ -1,9 +0,0 @@
-#include <stddef.h>
-
-#include "sqlite3.h"
-
-int go_progress(void *);
-
-void sqlite3_progress_handler_go(sqlite3 *db, int n) {
-  sqlite3_progress_handler(db, n, go_progress, /*arg=*/NULL);
-}

sqlite3/vfs_find.patch

@@ -1,7 +1,7 @@
 # Wrap sqlite3_vfs_find.
 --- sqlite3.c.orig
 +++ sqlite3.c
-@@ -25394,7 +25394,7 @@
+@@ -26089,7 +26089,7 @@
  ** Locate a VFS by name.  If no name is given, simply return the
  ** first VFS on the list.
  */

sqlite3/vtab.c

@@ -9,7 +9,7 @@
 #define SQLITE_VTAB_RENAMER_GO /******/ 0x08
 #define SQLITE_VTAB_OVERLOADER_GO /***/ 0x10
 #define SQLITE_VTAB_CHECKER_GO /******/ 0x20
-#define SQLITE_VTAB_TX_GO /***********/ 0x40
+#define SQLITE_VTAB_TXN_GO /**********/ 0x40
 #define SQLITE_VTAB_SAVEPOINTER_GO /**/ 0x80
 
 int go_vtab_create(sqlite3_module *, int argc, const char *const *argv,
@@ -193,7 +193,7 @@ int sqlite3_create_module_go(sqlite3 *db, const char *zName, int flags,
   if (flags & SQLITE_VTAB_CHECKER_GO) {
     mod->base.xIntegrity = go_vtab_integrity_wrapper;
   }
-  if (flags & SQLITE_VTAB_TX_GO) {
+  if (flags & SQLITE_VTAB_TXN_GO) {
     mod->base.xBegin = go_vtab_begin;
     mod->base.xSync = go_vtab_sync;
     mod->base.xCommit = go_vtab_commit;

stmt.go

@@ -111,6 +111,9 @@ func (s *Stmt) Exec() error {
 //
 // https://sqlite.org/c3ref/stmt_status.html
 func (s *Stmt) Status(op StmtStatus, reset bool) int {
+	if op > STMTSTATUS_FILTER_HIT && op != STMTSTATUS_MEMUSED {
+		return 0
+	}
 	var i uint64
 	if reset {
 		i = 1

tests/blob_test.go

@@ -371,6 +371,12 @@ func TestBlob_Reopen(t *testing.T) {
 		}
 		rowids = append(rowids, db.LastInsertRowID())
 	}
+	if changes := db.Changes(); changes != 1 {
+		t.Errorf("got %d want 1", changes)
+	}
+	if changes := db.TotalChanges(); changes != 100 {
+		t.Errorf("got %d want 100", changes)
+	}
 
 	var blob *sqlite3.Blob
 

tests/conn_test.go

@@ -3,6 +3,7 @@ package tests
 import (
 	"context"
 	"errors"
+	"math"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -364,3 +365,123 @@ func TestConn_ConfigLog(t *testing.T) {
 		t.Error("want sqlite3.ERROR")
 	}
 }
+
+func TestConn_Limit(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	l := db.Limit(sqlite3.LIMIT_COLUMN, -1)
+	if l != 2000 {
+		t.Errorf("got %d, want 2000", l)
+	}
+
+	l = db.Limit(sqlite3.LIMIT_COLUMN, 100)
+	if l != 2000 {
+		t.Errorf("got %d, want 2000", l)
+	}
+
+	l = db.Limit(sqlite3.LIMIT_COLUMN, -1)
+	if l != 100 {
+		t.Errorf("got %d, want 100", l)
+	}
+
+	l = db.Limit(math.MaxUint32, -1)
+	if l != -1 {
+		t.Errorf("got %d, want -1", l)
+	}
+}
+
+func TestConn_SetAuthorizer(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.SetAuthorizer(func(action sqlite3.AuthorizerActionCode, name3rd, name4th, schema, nameInner string) sqlite3.AuthorizerReturnCode {
+		return sqlite3.AUTH_DENY
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = db.Exec(`SELECT * FROM sqlite_schema`)
+	if !errors.Is(err, sqlite3.AUTH) {
+		t.Errorf("got %v, want sqlite3.AUTH", err)
+	}
+}
+
+func TestConn_ReleaseMemory(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	err = db.ReleaseMemory()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestConn_SetLastInsertRowID(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	db.SetLastInsertRowID(42)
+
+	got := db.LastInsertRowID()
+	if got != 42 {
+		t.Errorf("got %d, want 42", got)
+	}
+}
+
+func TestConn_ReadOnly(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	if ro, ok := db.ReadOnly(""); ro != false || ok != false {
+		t.Errorf("got %v,%v", ro, ok)
+	}
+
+	if ro, ok := db.ReadOnly("xpto"); ro != false || ok != true {
+		t.Errorf("got %v,%v", ro, ok)
+	}
+}
+
+func TestConn_DBName(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	if name := db.DBName(0); name != "main" {
+		t.Errorf("got %s", name)
+	}
+
+	if name := db.DBName(5); name != "" {
+		t.Errorf("got %s", name)
+	}
+}

tests/parallel/parallel_test.go

@@ -6,6 +6,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"testing"
+	"time"
 
 	"golang.org/x/sync/errgroup"
 
@@ -39,10 +40,7 @@ func TestMemory(t *testing.T) {
 		iter = 5000
 	}
 
-	name := "file:/test.db?vfs=memdb" +
-		"&_pragma=busy_timeout(10000)" +
-		"&_pragma=journal_mode(memory)" +
-		"&_pragma=synchronous(off)"
+	name := "file:/test.db?vfs=memdb"
 	testParallel(t, name, iter)
 	testIntegrity(t, name)
 }
@@ -100,10 +98,7 @@ func TestChildProcess(t *testing.T) {
 
 func BenchmarkMemory(b *testing.B) {
 	memdb.Delete("test.db")
-	name := "file:/test.db?vfs=memdb" +
-		"&_pragma=busy_timeout(10000)" +
-		"&_pragma=journal_mode(memory)" +
-		"&_pragma=synchronous(off)"
+	name := "file:/test.db?vfs=memdb"
 	testParallel(b, name, b.N)
 }
 
@@ -115,6 +110,14 @@ func testParallel(t testing.TB, name string, n int) {
 		}
 		defer db.Close()
 
+		err = db.BusyHandler(func(count int) (retry bool) {
+			time.Sleep(time.Millisecond)
+			return true
+		})
+		if err != nil {
+			return err
+		}
+
 		err = db.Exec(`CREATE TABLE IF NOT EXISTS users (id INT, name VARCHAR(10))`)
 		if err != nil {
 			return err
@@ -135,7 +138,7 @@ func testParallel(t testing.TB, name string, n int) {
 		}
 		defer db.Close()
 
-		err = db.Exec(`PRAGMA busy_timeout=10000`)
+		err = db.BusyTimeout(10 * time.Second)
 		if err != nil {
 			return err
 		}

tests/time_test.go

@@ -221,28 +221,6 @@ func TestDB_timeCollation(t *testing.T) {
 func TestDB_isoWeek(t *testing.T) {
 	t.Parallel()
 
-	tests := []time.Time{
-		time.Date(1977, 1, 1, 0, 0, 0, 0, time.UTC),
-		time.Date(1977, 1, 2, 0, 0, 0, 0, time.UTC),
-		time.Date(1977, 12, 31, 0, 0, 0, 0, time.UTC),
-		time.Date(1978, 1, 1, 0, 0, 0, 0, time.UTC),
-		time.Date(1978, 1, 2, 0, 0, 0, 0, time.UTC),
-		time.Date(1978, 12, 31, 0, 0, 0, 0, time.UTC),
-		time.Date(1979, 1, 1, 0, 0, 0, 0, time.UTC),
-		time.Date(1979, 1, 2, 0, 0, 0, 0, time.UTC),
-		time.Date(1979, 12, 31, 0, 0, 0, 0, time.UTC),
-		time.Date(1980, 1, 1, 0, 0, 0, 0, time.UTC),
-		time.Date(1980, 12, 28, 0, 0, 0, 0, time.UTC),
-		time.Date(1980, 12, 29, 0, 0, 0, 0, time.UTC),
-		time.Date(1980, 12, 30, 0, 0, 0, 0, time.UTC),
-		time.Date(1980, 12, 31, 0, 0, 0, 0, time.UTC),
-		time.Date(1981, 1, 1, 0, 0, 0, 0, time.UTC),
-		time.Date(1981, 12, 31, 0, 0, 0, 0, time.UTC),
-		time.Date(1982, 1, 1, 0, 0, 0, 0, time.UTC),
-		time.Date(1982, 1, 2, 0, 0, 0, 0, time.UTC),
-		time.Date(1982, 1, 3, 0, 0, 0, 0, time.UTC),
-	}
-
 	db, err := sqlite3.Open(":memory:")
 	if err != nil {
 		t.Fatal(err)
@@ -255,7 +233,9 @@ func TestDB_isoWeek(t *testing.T) {
 	}
 	defer stmt.Close()
 
-	for _, tm := range tests {
+	tend := time.Date(2500, 1, 1, 0, 0, 0, 0, time.UTC)
+	tstart := time.Date(1500, 1, 1, 12, 0, 0, 0, time.UTC)
+	for tm := tstart; tm.Before(tend); tm = tm.AddDate(0, 0, 1) {
 		stmt.BindTime(1, tm, sqlite3.TimeFormatDefault)
 		if stmt.Step() {
 			y, w := tm.ISOWeek()

tests/txn_test.go

@@ -18,6 +18,10 @@ func TestConn_Transaction_exec(t *testing.T) {
 	}
 	defer db.Close()
 
+	db.RollbackHook(func() {})
+	db.CommitHook(func() bool { return true })
+	db.UpdateHook(func(sqlite3.AuthorizerActionCode, string, string, int64) {})
+
 	err = db.Exec(`CREATE TABLE IF NOT EXISTS test (col)`)
 	if err != nil {
 		t.Fatal(err)
@@ -47,6 +51,10 @@ func TestConn_Transaction_exec(t *testing.T) {
 			t.Fatal(err)
 		}
 
+		if s := db.TxnState("main"); s != sqlite3.TXN_WRITE {
+			t.Errorf("got %d", s)
+		}
+
 		if succeed {
 			return nil
 		}

txn.go

@@ -8,50 +8,53 @@ import (
 	"runtime"
 	"strconv"
 	"strings"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+	"github.com/tetratelabs/wazero/api"
 )
 
-// Tx is an in-progress database transaction.
+// Txn is an in-progress database transaction.
 //
 // https://sqlite.org/lang_transaction.html
-type Tx struct {
+type Txn struct {
 	c *Conn
 }
 
 // Begin starts a deferred transaction.
 //
 // https://sqlite.org/lang_transaction.html
-func (c *Conn) Begin() Tx {
+func (c *Conn) Begin() Txn {
 	// BEGIN even if interrupted.
-	err := c.txExecInterrupted(`BEGIN DEFERRED`)
+	err := c.txnExecInterrupted(`BEGIN DEFERRED`)
 	if err != nil {
 		panic(err)
 	}
-	return Tx{c}
+	return Txn{c}
 }
 
 // BeginImmediate starts an immediate transaction.
 //
 // https://sqlite.org/lang_transaction.html
-func (c *Conn) BeginImmediate() (Tx, error) {
+func (c *Conn) BeginImmediate() (Txn, error) {
 	err := c.Exec(`BEGIN IMMEDIATE`)
 	if err != nil {
-		return Tx{}, err
+		return Txn{}, err
 	}
-	return Tx{c}, nil
+	return Txn{c}, nil
 }
 
 // BeginExclusive starts an exclusive transaction.
 //
 // https://sqlite.org/lang_transaction.html
-func (c *Conn) BeginExclusive() (Tx, error) {
+func (c *Conn) BeginExclusive() (Txn, error) {
 	err := c.Exec(`BEGIN EXCLUSIVE`)
 	if err != nil {
-		return Tx{}, err
+		return Txn{}, err
 	}
-	return Tx{c}, nil
+	return Txn{c}, nil
 }
 
-// End calls either [Tx.Commit] or [Tx.Rollback]
+// End calls either [Txn.Commit] or [Txn.Rollback]
 // depending on whether *error points to a nil or non-nil error.
 //
 // This is meant to be deferred:
@@ -64,7 +67,7 @@ func (c *Conn) BeginExclusive() (Tx, error) {
 //	}
 //
 // https://sqlite.org/lang_transaction.html
-func (tx Tx) End(errp *error) {
+func (tx Txn) End(errp *error) {
 	recovered := recover()
 	if recovered != nil {
 		defer panic(recovered)
@@ -95,7 +98,7 @@ func (tx Tx) End(errp *error) {
 // Commit commits the transaction.
 //
 // https://sqlite.org/lang_transaction.html
-func (tx Tx) Commit() error {
+func (tx Txn) Commit() error {
 	return tx.c.Exec(`COMMIT`)
 }
 
@@ -103,8 +106,8 @@ func (tx Tx) Commit() error {
 // even if the connection has been interrupted.
 //
 // https://sqlite.org/lang_transaction.html
-func (tx Tx) Rollback() error {
-	return tx.c.txExecInterrupted(`ROLLBACK`)
+func (tx Txn) Rollback() error {
+	return tx.c.txnExecInterrupted(`ROLLBACK`)
 }
 
 // Savepoint is a marker within a transaction
@@ -123,7 +126,7 @@ func (c *Conn) Savepoint() Savepoint {
 	// Names can be reused; this makes catching bugs more likely.
 	name := saveptName() + "_" + strconv.Itoa(int(rand.Int31()))
 
-	err := c.txExecInterrupted(fmt.Sprintf("SAVEPOINT %q;", name))
+	err := c.txnExecInterrupted(fmt.Sprintf("SAVEPOINT %q;", name))
 	if err != nil {
 		panic(err)
 	}
@@ -185,7 +188,7 @@ func (s Savepoint) Release(errp *error) {
 		return
 	}
 	// ROLLBACK and RELEASE even if interrupted.
-	err := s.c.txExecInterrupted(fmt.Sprintf(`
+	err := s.c.txnExecInterrupted(fmt.Sprintf(`
 		ROLLBACK TO %[1]q;
 		RELEASE %[1]q;
 	`, s.name))
@@ -201,10 +204,10 @@ func (s Savepoint) Release(errp *error) {
 // https://sqlite.org/lang_transaction.html
 func (s Savepoint) Rollback() error {
 	// ROLLBACK even if interrupted.
-	return s.c.txExecInterrupted(fmt.Sprintf("ROLLBACK TO %q;", s.name))
+	return s.c.txnExecInterrupted(fmt.Sprintf("ROLLBACK TO %q;", s.name))
 }
 
-func (c *Conn) txExecInterrupted(sql string) error {
+func (c *Conn) txnExecInterrupted(sql string) error {
 	err := c.Exec(sql)
 	if errors.Is(err, INTERRUPT) {
 		old := c.SetInterrupt(context.Background())
@@ -213,3 +216,82 @@ func (c *Conn) txExecInterrupted(sql string) error {
 	}
 	return err
 }
+
+// TxnState starts a deferred transaction.
+//
+// https://sqlite.org/c3ref/txn_state.html
+func (c *Conn) TxnState(schema string) TxnState {
+	var ptr uint32
+	if schema != "" {
+		defer c.arena.mark()()
+		ptr = c.arena.string(schema)
+	}
+	r := c.call("sqlite3_txn_state", uint64(c.handle), uint64(ptr))
+	return TxnState(r)
+}
+
+// Deprecated: renamed for consistency with [Conn.TxnState].
+type Tx = Txn
+
+// CommitHook registers a callback function to be invoked
+// whenever a transaction is committed.
+// Return true to allow the commit operation to continue normally.
+//
+// https://sqlite.org/c3ref/commit_hook.html
+func (c *Conn) CommitHook(cb func() (ok bool)) {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	c.call("sqlite3_commit_hook_go", uint64(c.handle), enable)
+	c.commit = cb
+}
+
+// RollbackHook registers a callback function to be invoked
+// whenever a transaction is rolled back.
+//
+// https://sqlite.org/c3ref/commit_hook.html
+func (c *Conn) RollbackHook(cb func()) {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	c.call("sqlite3_rollback_hook_go", uint64(c.handle), enable)
+	c.rollback = cb
+}
+
+// RollbackHook registers a callback function to be invoked
+// whenever a row is updated, inserted or deleted in a rowid table.
+//
+// https://sqlite.org/c3ref/update_hook.html
+func (c *Conn) UpdateHook(cb func(action AuthorizerActionCode, schema, table string, rowid int64)) {
+	var enable uint64
+	if cb != nil {
+		enable = 1
+	}
+	c.call("sqlite3_update_hook_go", uint64(c.handle), enable)
+	c.update = cb
+}
+
+func commitCallback(ctx context.Context, mod api.Module, pDB uint32) uint32 {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.commit != nil {
+		if ok := c.commit(); !ok {
+			return 1
+		}
+	}
+	return 0
+}
+
+func rollbackCallback(ctx context.Context, mod api.Module, pDB uint32) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.rollback != nil {
+		c.rollback()
+	}
+}
+
+func updateCallback(ctx context.Context, mod api.Module, pDB uint32, action AuthorizerActionCode, zSchema, zTabName uint32, rowid uint64) {
+	if c, ok := ctx.Value(connKey{}).(*Conn); ok && c.handle == pDB && c.update != nil {
+		schema := util.ReadString(mod, zSchema, _MAX_NAME)
+		table := util.ReadString(mod, zTabName, _MAX_NAME)
+		c.update(action, schema, table, int64(rowid))
+	}
+}

value.go

@@ -204,7 +204,7 @@ func (v Value) NoChange() bool {
 // InFirst returns the first element
 // on the right-hand side of an IN constraint.
 //
-// https://www.sqlite.org/c3ref/vtab_in_first.html
+// https://sqlite.org/c3ref/vtab_in_first.html
 func (v Value) InFirst() (Value, error) {
 	defer v.c.arena.mark()()
 	valPtr := v.c.arena.new(ptrlen)
@@ -221,7 +221,7 @@ func (v Value) InFirst() (Value, error) {
 // InNext returns the next element
 // on the right-hand side of an IN constraint.
 //
-// https://www.sqlite.org/c3ref/vtab_in_first.html
+// https://sqlite.org/c3ref/vtab_in_first.html
 func (v Value) InNext() (Value, error) {
 	defer v.c.arena.mark()()
 	valPtr := v.c.arena.new(ptrlen)

vfs/os_nolock.go

@@ -4,6 +4,14 @@ package vfs
 
 import "os"
 
+// SupportsFileLocking is false on platforms that do not support file locking.
+// To open a database file in one such platform,
+// you need to use the [nolock] or [immutable] URI parameters.
+//
+// [nolock]: https://sqlite.org/uri.html#urinolock
+// [immutable]: https://sqlite.org/uri.html#uriimmutable
+const SupportsFileLocking = false
+
 func osGetSharedLock(file *os.File) _ErrorCode {
 	return _IOERR_RDLOCK
 }

vfs/os_unix_lock.go

@@ -9,6 +9,14 @@ import (
 	"golang.org/x/sys/unix"
 )
 
+// SupportsFileLocking is false on platforms that do not support file locking.
+// To open a database file in one such platform,
+// you need to use the [nolock] or [immutable] URI parameters.
+//
+// [nolock]: https://sqlite.org/uri.html#urinolock
+// [immutable]: https://sqlite.org/uri.html#uriimmutable
+const SupportsFileLocking = true
+
 func osGetSharedLock(file *os.File) _ErrorCode {
 	// Test the PENDING lock before acquiring a new SHARED lock.
 	if pending, _ := osCheckLock(file, _PENDING_BYTE, 1); pending {

vfs/os_windows.go

@@ -9,6 +9,14 @@ import (
 	"golang.org/x/sys/windows"
 )
 
+// SupportsFileLocking is false on platforms that do not support file locking.
+// To open a database file in one such platform,
+// you need to use the [nolock] or [immutable] URI parameters.
+//
+// [nolock]: https://sqlite.org/uri.html#urinolock
+// [immutable]: https://sqlite.org/uri.html#uriimmutable
+const SupportsFileLocking = true
+
 func osGetSharedLock(file *os.File) _ErrorCode {
 	// Acquire the PENDING lock temporarily before acquiring a new SHARED lock.
 	rc := osReadLock(file, _PENDING_BYTE, 1, 0)
@@ -49,7 +57,7 @@ func osGetExclusiveLock(file *os.File) _ErrorCode {
 
 func osDowngradeLock(file *os.File, state LockLevel) _ErrorCode {
 	if state >= LOCK_EXCLUSIVE {
-		// Release the SHARED lock.
+		// Release the EXCLUSIVE lock.
 		osUnlock(file, _SHARED_FIRST, _SHARED_SIZE)
 
 		// Reacquire the SHARED lock.

vfs/tests/mptest/mptest_test.go

@@ -129,6 +129,9 @@ func Test_crash01(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping in short mode")
 	}
+	if os.Getenv("CI") != "" {
+		t.Skip("skipping in CI")
+	}
 
 	ctx := util.NewContext(newContext(t))
 	name := filepath.Join(t.TempDir(), "test.db")
@@ -157,10 +160,8 @@ func Test_multiwrite01(t *testing.T) {
 
 func Test_config01_memory(t *testing.T) {
 	ctx := util.NewContext(newContext(t))
-	cfg := config(ctx).WithArgs("mptest", "/test.db",
-		"config01.test",
-		"--vfs", "memdb",
-		"--timeout", "1000")
+	cfg := config(ctx).WithArgs("mptest", "/test.db", "config01.test",
+		"--vfs", "memdb")
 	mod, err := rt.InstantiateModule(ctx, module, cfg)
 	if err != nil {
 		t.Fatal(err)
@@ -174,10 +175,8 @@ func Test_multiwrite01_memory(t *testing.T) {
 	}
 
 	ctx := util.NewContext(newContext(t))
-	cfg := config(ctx).WithArgs("mptest", "/test.db",
-		"multiwrite01.test",
-		"--vfs", "memdb",
-		"--timeout", "1000")
+	cfg := config(ctx).WithArgs("mptest", "/test.db", "multiwrite01.test",
+		"--vfs", "memdb")
 	mod, err := rt.InstantiateModule(ctx, module, cfg)
 	if err != nil {
 		t.Fatal(err)

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

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

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

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

vtab.go

@@ -22,7 +22,7 @@ func CreateModule[T VTab](db *Conn, name string, create, connect VTabConstructor
 		VTAB_RENAMER     = 0x08
 		VTAB_OVERLOADER  = 0x10
 		VTAB_CHECKER     = 0x20
-		VTAB_TX          = 0x40
+		VTAB_TXN         = 0x40
 		VTAB_SAVEPOINTER = 0x80
 	)
 
@@ -46,8 +46,8 @@ func CreateModule[T VTab](db *Conn, name string, create, connect VTabConstructor
 	if implements[VTabChecker](vtab) {
 		flags |= VTAB_CHECKER
 	}
-	if implements[VTabTx](vtab) {
-		flags |= VTAB_TX
+	if implements[VTabTxn](vtab) {
+		flags |= VTAB_TXN
 	}
 	if implements[VTabSavepointer](vtab) {
 		flags |= VTAB_SAVEPOINTER
@@ -78,7 +78,7 @@ func (c *Conn) DeclareVTab(sql string) error {
 
 // VTabConflictMode is a virtual table conflict resolution mode.
 //
-// https://www.sqlite.org/c3ref/c_fail.html
+// https://sqlite.org/c3ref/c_fail.html
 type VTabConflictMode uint8
 
 const (
@@ -128,6 +128,13 @@ type VTabConstructor[T VTab] func(db *Conn, module, schema, table string, arg ..
 
 type module[T VTab] [2]VTabConstructor[T]
 
+type vtabConstructor int
+
+const (
+	xCreate  vtabConstructor = 0
+	xConnect vtabConstructor = 1
+)
+
 // A VTab describes a particular instance of the virtual table.
 // A VTab may optionally implement [io.Closer] to free resources.
 //
@@ -180,14 +187,14 @@ type VTabChecker interface {
 	Integrity(schema, table string, flags int) error
 }
 
-// A VTabTx allows a virtual table to implement
+// A VTabTxn allows a virtual table to implement
 // transactions with two-phase commit.
 //
 // Anything that is required as part of a commit that may fail
 // should be performed in the Sync() callback.
 // Current versions of SQLite ignore any errors
 // returned by Commit() and Rollback().
-type VTabTx interface {
+type VTabTxn interface {
 	VTab
 	// https://sqlite.org/vtab.html#xBegin
 	Begin() error
@@ -199,12 +206,15 @@ type VTabTx interface {
 	Rollback() error
 }
 
+// Deprecated: renamed for consistency with [Conn.TxnState].
+type VTabTx = VTabTxn
+
 // A VTabSavepointer allows a virtual table to implement
 // nested transactions.
 //
 // https://sqlite.org/vtab.html#xsavepoint
 type VTabSavepointer interface {
-	VTabTx
+	VTabTxn
 	Savepoint(id int) error
 	Release(id int) error
 	RollbackTo(id int) error
@@ -414,7 +424,7 @@ const (
 	INDEX_SCAN_UNIQUE IndexScanFlag = 1
 )
 
-func vtabModuleCallback(i int) func(_ context.Context, _ api.Module, _, _, _, _, _ uint32) uint32 {
+func vtabModuleCallback(i vtabConstructor) func(_ context.Context, _ api.Module, _, _, _, _, _ uint32) uint32 {
 	return func(ctx context.Context, mod api.Module, pMod, nArg, pArg, ppVTab, pzErr uint32) uint32 {
 		arg := make([]reflect.Value, 1+nArg)
 		arg[0] = reflect.ValueOf(ctx.Value(connKey{}))
@@ -425,7 +435,7 @@ func vtabModuleCallback(i int) func(_ context.Context, _ api.Module, _, _, _, _,
 		}
 
 		module := vtabGetHandle(ctx, mod, pMod)
-		res := reflect.ValueOf(module).Index(i).Call(arg)
+		res := reflect.ValueOf(module).Index(int(i)).Call(arg)
 		err, _ := res[1].Interface().(error)
 		if err == nil {
 			vtabPutHandle(ctx, mod, ppVTab, res[0].Interface())
@@ -509,25 +519,25 @@ func vtabIntegrityCallback(ctx context.Context, mod api.Module, pVTab, zSchema,
 }
 
 func vtabBeginCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
-	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTx)
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn)
 	err := vtab.Begin()
 	return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
 }
 
 func vtabSyncCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
-	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTx)
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn)
 	err := vtab.Sync()
 	return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
 }
 
 func vtabCommitCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
-	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTx)
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn)
 	err := vtab.Commit()
 	return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
 }
 
 func vtabRollbackCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
-	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTx)
+	vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn)
 	err := vtab.Rollback()
 	return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
 }