Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package rqlite for openSUSE:Factory checked in at 2026-09-21 12:15:17 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/rqlite (Old) and /work/SRC/openSUSE:Factory/.rqlite.new.383539 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "rqlite" Mon Sep 21 12:15:17 2026 rev:55 rq:1379224 version:10.3.5 Changes: -------- --- /work/SRC/openSUSE:Factory/rqlite/rqlite.changes 2026-09-04 12:43:38.829405305 +0200 +++ /work/SRC/openSUSE:Factory/.rqlite.new.383539/rqlite.changes 2026-09-21 12:15:52.126854295 +0200 @@ -1,0 +2,38 @@ +Sun Sep 20 08:37:06 UTC 2026 - Andreas Stieger <[email protected]> + +- Update to version 10.3.5: + * Reject alternate form of unsupported PRAGMA commands + * Handle negative trailing logs + * Sync access to last backup time at http layer + * Set the "Served by" header before first backup byte + * Set DB load response time for all formats + * Fix HTTP logic error for queued statements + * Minor web console fixes +- includes changes from 10.0.4: + * Do not emit rolled-back events over CDC +- includes changes from 10.0.3: + * Refactor busy timeout methods + * Fix edge-case bugs detected by GPT-6 Astra + * Switch to quay.io/minio/minio:latest for testing purposes + * Fix removing a node with different ID, but same Raft address + * Use correct Foreign Key setting when recovering node + * Only dump the indexes and triggers of the selected tables + * Detect DB changes during Request(RETURNING) + * Snapshot Open() first checks for failed reap + * Sync snapshot plan directory + * Propagate WAL stat errors + * Clean up cancelled snapshots + * Reject incomplete snapshot headers + * Validate restore database header + * Only reap a sole fullsnapshot if it has zero WALs + * Keep database dumps consistent during writes to the database + * Roll back DB Requests on statement-prepare errors +- includes changes from 10.0.2: + * Upgrade SQLite driver + * Unit test reaping an installed Snapshot and streamed Snapshot combo + * Use distinct Snapshot Namer type + * Replace breaking-pragma regexes with ASCII prefix scanning + * Consolidate pragma and txStatus reads onto a single connection per pool + * Fix some magic strings in db package + +------------------------------------------------------------------- Old: ---- rqlite-10.3.1.tar.xz New: ---- rqlite-10.3.5.tar.xz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ rqlite.spec ++++++ --- /var/tmp/diff_new_pack.OMDmf8/_old 2026-09-21 12:15:53.477910767 +0200 +++ /var/tmp/diff_new_pack.OMDmf8/_new 2026-09-21 12:15:53.480910892 +0200 @@ -17,14 +17,14 @@ Name: rqlite -Version: 10.3.1 +Version: 10.3.5 Release: 0 Summary: Distributed relational database built on SQLite License: MIT URL: https://rqlite.io/ Source: %{name}-%{version}.tar.xz Source1: vendor.tar.xz -BuildRequires: go >= 1.26.0 +BuildRequires: go >= 1.27.0 BuildRequires: golang-packaging BuildRequires: pkgconfig BuildRequires: pkgconfig(sqlite3) ++++++ _service ++++++ --- /var/tmp/diff_new_pack.OMDmf8/_old 2026-09-21 12:15:53.564914403 +0200 +++ /var/tmp/diff_new_pack.OMDmf8/_new 2026-09-21 12:15:53.576914905 +0200 @@ -3,7 +3,7 @@ <param name="url">https://github.com/rqlite/rqlite.git</param> <param name="scm">git</param> <param name="exclude">.git</param> - <param name="revision">v10.3.1</param> + <param name="revision">v10.3.5</param> <param name="versionformat">@PARENT_TAG@</param> <param name="changesgenerate">enable</param> <param name="versionrewrite-pattern">v(.*)</param> ++++++ _servicedata ++++++ --- /var/tmp/diff_new_pack.OMDmf8/_old 2026-09-21 12:15:53.634917329 +0200 +++ /var/tmp/diff_new_pack.OMDmf8/_new 2026-09-21 12:15:53.652918082 +0200 @@ -1,7 +1,7 @@ <servicedata> <service name="tar_scm"> <param name="url">https://github.com/rqlite/rqlite.git</param> - <param name="changesrevision">c1a3b427827b3babc8c5fa7a7ad35ab2f9d598b0</param> + <param name="changesrevision">58f9d8898a5f5d4bf712d472f96e38cc7cb4748a</param> </service> </servicedata> (No newline at EOF) ++++++ rqlite-10.3.1.tar.xz -> rqlite-10.3.5.tar.xz ++++++ ++++ 3885 lines of diff (skipped) ++++++ vendor.tar.xz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/callback.go new/vendor/github.com/mattn/go-sqlite3/callback.go --- old/vendor/github.com/mattn/go-sqlite3/callback.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/callback.go 2026-09-18 16:05:02.000000000 +0200 @@ -29,7 +29,6 @@ "math" "reflect" "sync" - "sync/atomic" "unsafe" ) @@ -104,27 +103,28 @@ val any } -var handleLock sync.Mutex -var handleVals atomic.Value // stores map[unsafe.Pointer]handleVal +// handleVals maps unsafe.Pointer handles to handleVal. A sync.Map keeps +// lookups lock-free on the hot callback path while insertion and removal +// stay O(1); the previous copy-on-write map made every registration copy +// the whole table, so opening N connections (each registering several +// functions) was quadratic in time and allocation. +var handleVals sync.Map func newHandle(db *SQLiteConn, v any) unsafe.Pointer { - val := handleVal{db: db, val: v} var p unsafe.Pointer = C.malloc(C.size_t(1)) if p == nil { panic("can't allocate 'cgo-pointer hack index pointer': ptr == nil") } - - handleLock.Lock() - defer handleLock.Unlock() - - next := cloneHandleVals(len(loadHandleVals()) + 1) - next[p] = val - handleVals.Store(next) + handleVals.Store(p, handleVal{db: db, val: v}) return p } func lookupHandleVal(handle unsafe.Pointer) handleVal { - return loadHandleVals()[handle] + v, ok := handleVals.Load(handle) + if !ok { + return handleVal{} + } + return v.(handleVal) } func lookupHandle(handle unsafe.Pointer) any { @@ -134,55 +134,20 @@ // deleteHandle releases a single handle created by newHandle. It is a no-op // if the handle is unknown (e.g. already released). func deleteHandle(handle unsafe.Pointer) { - handleLock.Lock() - defer handleLock.Unlock() - - current := loadHandleVals() - if _, ok := current[handle]; !ok { - return + if _, ok := handleVals.LoadAndDelete(handle); ok { + C.free(handle) } - next := make(map[unsafe.Pointer]handleVal, len(current)-1) - for h, v := range current { - if h == handle { - continue - } - next[h] = v - } - handleVals.Store(next) - C.free(handle) } func deleteHandles(db *SQLiteConn) { - handleLock.Lock() - defer handleLock.Unlock() - - current := loadHandleVals() - if len(current) == 0 { - return - } - - next := make(map[unsafe.Pointer]handleVal, len(current)) - for handle, val := range current { - if val.db == db { - C.free(handle) - continue + handleVals.Range(func(handle, val any) bool { + if val.(handleVal).db == db { + if _, ok := handleVals.LoadAndDelete(handle); ok { + C.free(handle.(unsafe.Pointer)) + } } - next[handle] = val - } - handleVals.Store(next) -} - -func loadHandleVals() map[unsafe.Pointer]handleVal { - m, _ := handleVals.Load().(map[unsafe.Pointer]handleVal) - return m -} - -func cloneHandleVals(size int) map[unsafe.Pointer]handleVal { - next := make(map[unsafe.Pointer]handleVal, size) - for handle, val := range loadHandleVals() { - next[handle] = val - } - return next + return true + }) } // This is only here so that tests can refer to it. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/convert.go new/vendor/github.com/mattn/go-sqlite3/convert.go --- old/vendor/github.com/mattn/go-sqlite3/convert.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/convert.go 2026-09-18 16:05:02.000000000 +0200 @@ -159,7 +159,7 @@ } dpv := reflect.ValueOf(dest) - if dpv.Kind() != reflect.Ptr { + if dpv.Kind() != reflect.Pointer { return errors.New("destination not a pointer") } if dpv.IsNil() { @@ -192,7 +192,7 @@ // This also allows scanning into user defined types such as "type Int int64". // For symmetry, also check for string destination types. switch dv.Kind() { - case reflect.Ptr: + case reflect.Pointer: if src == nil { dv.Set(reflect.Zero(dv.Type())) return nil diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3.go new/vendor/github.com/mattn/go-sqlite3/sqlite3.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3.go 2026-09-18 16:05:02.000000000 +0200 @@ -235,6 +235,86 @@ } #endif +// Resets a statement, binds positional arguments, takes the first step +// and reports the post-step column count and cumulative re-prepare +// count, all in a single CGO crossing. Arguments arrive as +// sqlite3_go_col records whose typ selects the bind: SQLITE_INTEGER, +// SQLITE_FLOAT, SQLITE_TEXT and SQLITE_BLOB bind the respective field +// (ptr points into C memory owned by the Go side and bound with +// SQLITE_STATIC), anything else binds NULL. Returns the bind error +// code with *ncol == -1 when a bind fails. +static int +_sqlite3_bind_step_columns(sqlite3_stmt* stmt, sqlite3_go_col* args, int nargs, int* ncol, int* repreps, sqlite3_go_col* cols, int colcap, int* filled) +{ + int i; + int rv = sqlite3_reset(stmt); + *filled = 0; + if (rv != SQLITE_OK && rv != SQLITE_ROW && rv != SQLITE_DONE) { + *ncol = -1; + return rv; + } + sqlite3_clear_bindings(stmt); + for (i = 0; i < nargs; i++) { + sqlite3_go_col* a = &args[i]; + switch (a->typ) { + case SQLITE_INTEGER: + rv = sqlite3_bind_int64(stmt, i+1, a->i64); + break; + case SQLITE_FLOAT: + rv = sqlite3_bind_double(stmt, i+1, a->f64); + break; + case SQLITE_TEXT: + rv = sqlite3_bind_text64(stmt, i+1, (const char*)a->ptr, a->n, SQLITE_STATIC, SQLITE_UTF8); + break; + case SQLITE_BLOB: + rv = sqlite3_bind_blob64(stmt, i+1, a->ptr, a->n, SQLITE_STATIC); + break; + default: + rv = sqlite3_bind_null(stmt, i+1); + break; + } + if (rv != SQLITE_OK) { + *ncol = -1; + return rv; + } + } + rv = _sqlite3_step_internal(stmt); + *ncol = sqlite3_column_count(stmt); +#ifdef SQLITE_STMTSTATUS_REPREPARE + *repreps = sqlite3_stmt_status(stmt, SQLITE_STMTSTATUS_REPREPARE, 0); +#else + *repreps = -1; +#endif + // When the row buffer is already large enough, deliver the first + // row's values in the same crossing. + if (rv == SQLITE_ROW && cols != 0 && *ncol <= colcap) { + _sqlite3_column_values(stmt, *ncol, cols); + *filled = 1; + } else { + *filled = 0; + } + return rv; +} + +// Steps a statement once and reports the post-step column count and the +// cumulative re-prepare count, in a single CGO crossing. Used for the +// eager first step of cached statements: only after the first step is an +// expired statement guaranteed to have been re-prepared following a +// schema change, so only then do the column count and metadata describe +// the current schema. +static int +_sqlite3_step_columns(sqlite3_stmt* stmt, int* ncol, int* repreps) +{ + int rv = _sqlite3_step_internal(stmt); + *ncol = sqlite3_column_count(stmt); +#ifdef SQLITE_STMTSTATUS_REPREPARE + *repreps = sqlite3_stmt_status(stmt, SQLITE_STMTSTATUS_REPREPARE, 0); +#else + *repreps = -1; +#endif + return rv; +} + void _sqlite3_result_text(sqlite3_context* ctx, const char* s, int n) { sqlite3_result_text(ctx, s, n, &free); } @@ -460,8 +540,11 @@ // SQLiteConn implements driver.Conn. type SQLiteConn struct { - mu sync.Mutex - db *C.sqlite3 + mu sync.Mutex + db *C.sqlite3 + // activeRows identifies the cancellable Rows currently calling sqlite3_step. + // It is guarded by mu so a stale cancellation cannot interrupt later work. + activeRows *SQLiteRows loc *time.Location txlock string funcs []*functionInfo @@ -489,9 +572,27 @@ t string closed bool cls bool // True if the statement was created by SQLiteConn.Query + numInput int32 namedParams map[string][3]int cacheKey string metadata *sqliteStmtMetadata + // repreps is the statement's cumulative re-prepare count observed + // at the last eager first step; a change means SQLite re-prepared + // the statement after a schema change and metadata must be rebuilt. + repreps C.int + // argBuf is C memory owned by the statement holding the bytes of + // text/blob/time arguments for the fused bind path; the bytes are + // bound with SQLITE_STATIC and stay valid until the next bind or + // finalize. colvals is the statement-owned row buffer reused by + // every SQLiteRows of this statement. + argBuf unsafe.Pointer + argBufCap int + colvals *C.sqlite3_go_col + colvalsCap int32 + // cargs is reused across queries of this statement to avoid a + // per-query allocation; a statement has at most one query binding + // at a time. + cargs []C.sqlite3_go_col } type sqliteStmtMetadata struct { @@ -507,14 +608,20 @@ // SQLiteRows implements driver.Rows. type SQLiteRows struct { - s *SQLiteStmt - nc int32 // Number of columns - cls bool // True if we need to close the parent statement in Close - cols []string - decltype []string - colvals *C.sqlite3_go_col - ctx context.Context // no better alternative to pass context into Next() method - closemu sync.Mutex + s *SQLiteStmt + nc int32 // Number of columns + cls bool // True if we need to close the parent statement in Close + cols []string + decltype []string + colvals *C.sqlite3_go_col + ctx context.Context // no better alternative to pass context into Next() method + stopCancellation func() bool + // pendingStep buffers the result of the eager first step taken in + // query(); -1 when no step is buffered. pendingFilled reports that + // the buffered row's column values are already in colvals. + pendingStep C.int + pendingFilled bool + closemu sync.Mutex } type functionInfo struct { @@ -983,7 +1090,7 @@ na := s.NumInput() if len(args)-start < na { s.Close() - return nil, fmt.Errorf("not enough args to execute query: want %d got %d", na, len(args)) + return nil, fmt.Errorf("not enough args to execute query: want %d got %d", na, len(args)-start) } stmtArgs := stmtArgs(args, start, na) res, err = s.(*SQLiteStmt).exec(ctx, stmtArgs) @@ -1624,6 +1731,18 @@ return nil, err } + if conn.stmtCacheEnabled && int(C.sqlite3_libversion_number()) < 3020000 { + // Schema-change detection for cached statements relies on + // SQLITE_STMTSTATUS_REPREPARE (3.20.0); with an older runtime + // library run without the cache rather than risk serving + // statements whose metadata a schema change has expired. The + // compile-time check in _sqlite3_step_columns is not enough: + // with USE_LIBSQLITE3 the header and the runtime library can + // differ. + conn.stmtCache = nil + conn.stmtCacheEnabled = false + } + exec := func(s string) error { cs := C.CString(s) rv := C.sqlite3_exec(db, cs, nil, nil, nil) @@ -2014,6 +2133,7 @@ return } runtime.SetFinalizer(s, nil) + s.freeScratch() if s.s != nil { C.sqlite3_finalize(s.s) s.s = nil @@ -2041,6 +2161,9 @@ t = strings.TrimSpace(C.GoString(tail)) } ss := &SQLiteStmt{c: c, s: s, t: t} + if s != nil { + ss.numInput = int32(C.sqlite3_bind_parameter_count(s)) + } runtime.SetFinalizer(ss, (*SQLiteStmt).Close) return ss, nil } @@ -2169,6 +2292,20 @@ return nil } +// freeScratch releases the statement-owned argument and row buffers. +func (s *SQLiteStmt) freeScratch() { + if s.argBuf != nil { + C.free(s.argBuf) + s.argBuf = nil + s.argBufCap = 0 + } + if s.colvals != nil { + C.free(unsafe.Pointer(s.colvals)) + s.colvals = nil + s.colvalsCap = 0 + } +} + // Close the statement. func (s *SQLiteStmt) Close() error { s.mu.Lock() @@ -2200,6 +2337,7 @@ } s.s = nil s.c = nil + s.freeScratch() rv := C.sqlite3_finalize(stmt) if rv != C.SQLITE_OK { return conn.lastError() @@ -2209,7 +2347,7 @@ // NumInput return a number of parameters. func (s *SQLiteStmt) NumInput() int { - return int(C.sqlite3_bind_parameter_count(s.s)) + return int(s.numInput) } var placeHolder = []byte{0} @@ -2374,27 +2512,117 @@ } func (s *SQLiteStmt) query(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) { - if err := s.bind(args); err != nil { + rows := &SQLiteRows{ + s: s, + cls: s.cls, + ctx: ctx, + pendingStep: -1, + } + // The first step is taken eagerly (it was going to run at the first + // Next anyway): only after it are the column count and metadata of a + // statement expired by a schema change guaranteed to describe the + // current schema, and folding reset, bind and step into one CGO + // crossing removes most of the per-query CGO overhead. Note that a + // data-modifying statement issued through Query therefore executes + // even if Next is never called. + rv, err := rows.bindAndFirstStepLocked(args) + if err != nil { return nil, err } + rows.pendingStep = rv - rows := &SQLiteRows{ - s: s, - nc: int32(C.sqlite3_column_count(s.s)), - cls: s.cls, - cols: nil, - decltype: nil, - colvals: nil, - ctx: ctx, - } - if rows.nc > 0 { - rows.colvals = (*C.sqlite3_go_col)(C.malloc(C.size_t(rows.nc) * C.size_t(unsafe.Sizeof(C.sqlite3_go_col{})))) - if rows.colvals == nil { - return nil, errors.New("sqlite3: failed to allocate row buffer") + return rows, nil +} + +// marshalFusedArgs converts positional arguments into sqlite3_go_col +// records for _sqlite3_bind_step_columns. Text, blob and time arguments +// are copied into the statement-owned C scratch buffer so the records +// contain no Go pointers and the bytes can be bound with SQLITE_STATIC. +// It reports false when the arguments need the generic bind path. +func (s *SQLiteStmt) marshalFusedArgs(args []driver.NamedValue, cargs []C.sqlite3_go_col) bool { + need := 0 + for i := range args { + if args[i].Name != "" || args[i].Ordinal != i+1 { + return false + } + switch v := args[i].Value.(type) { + case string: + need += len(v) + case []byte: + need += len(v) + case time.Time: + need += len(SQLiteTimestampFormats[0]) + 16 + } + } + if need > s.argBufCap { + if s.argBuf != nil { + C.free(s.argBuf) + } + s.argBuf = C.malloc(C.size_t(need)) + if s.argBuf == nil { + s.argBufCap = 0 + panic("sqlite3: failed to allocate argument buffer") + } + s.argBufCap = need + } + var buf []byte + if s.argBufCap > 0 { + buf = unsafe.Slice((*byte)(s.argBuf), s.argBufCap) + } + off := 0 + putBytes := func(a *C.sqlite3_go_col, b []byte) { + // A NULL pointer would bind SQL NULL, so empty values point at + // the buffer base (the C side never dereferences n == 0). + a.ptr = s.argBuf + if len(b) > 0 { + a.ptr = unsafe.Add(s.argBuf, off) + off += copy(buf[off:], b) } + a.n = C.int(len(b)) } - - return rows, nil + for i := range args { + a := &cargs[i] + switch v := args[i].Value.(type) { + case nil: + a.typ = C.SQLITE_NULL + case int64: + a.typ = C.SQLITE_INTEGER + a.i64 = C.sqlite3_int64(v) + case bool: + a.typ = C.SQLITE_INTEGER + if v { + a.i64 = 1 + } else { + a.i64 = 0 + } + case float64: + a.typ = C.SQLITE_FLOAT + a.f64 = C.double(v) + case string: + if s.argBuf == nil { + return false + } + a.typ = C.SQLITE_TEXT + putBytes(a, unsafe.Slice(unsafe.StringData(v), len(v))) + case []byte: + if v == nil { + a.typ = C.SQLITE_NULL + break + } + if s.argBuf == nil { + return false + } + a.typ = C.SQLITE_BLOB + putBytes(a, v) + case time.Time: + var tmp [64]byte + a.typ = C.SQLITE_TEXT + putBytes(a, v.AppendFormat(tmp[:0], SQLiteTimestampFormats[0])) + default: + return false + } + } + return true } // LastInsertId return last inserted ID. @@ -2491,19 +2719,14 @@ func (rc *SQLiteRows) Close() error { rc.closemu.Lock() defer rc.closemu.Unlock() + rc.stopWatchingCancellation() s := rc.s if s == nil { - if rc.colvals != nil { - C.free(unsafe.Pointer(rc.colvals)) - rc.colvals = nil - } return nil } rc.s = nil // remove reference to SQLiteStmt - if rc.colvals != nil { - C.free(unsafe.Pointer(rc.colvals)) - rc.colvals = nil - } + // rc.colvals is owned by the statement and released with it. + rc.colvals = nil s.mu.Lock() if s.closed { s.mu.Unlock() @@ -2522,6 +2745,40 @@ return nil } +func (c *SQLiteConn) interruptActiveRows(rows *SQLiteRows) { + c.mu.Lock() + defer c.mu.Unlock() + if c.activeRows == rows && c.db != nil { + C.sqlite3_interrupt(c.db) + } +} + +func (rc *SQLiteRows) stopWatchingCancellation() { + if rc.stopCancellation == nil { + return + } + // A false return is harmless: a callback already in progress can interrupt + // only while rc owns conn.activeRows, which is guarded by conn.mu. + rc.stopCancellation() + rc.stopCancellation = nil +} + +func (rc *SQLiteRows) startStepping() { + conn := rc.s.c + conn.mu.Lock() + conn.activeRows = rc + conn.mu.Unlock() +} + +func (rc *SQLiteRows) finishStepping() { + conn := rc.s.c + conn.mu.Lock() + if conn.activeRows == rc { + conn.activeRows = nil + } + conn.mu.Unlock() +} + func (s *SQLiteStmt) cacheMetadata() bool { return !s.cls || s.cacheKey != "" } @@ -2608,33 +2865,141 @@ return io.EOF } - if rc.ctx.Done() == nil { - return rc.nextSyncLocked(dest) + if rv := rc.pendingStep; rv >= 0 { + rc.pendingStep = -1 + filled := rc.pendingFilled + rc.pendingFilled = false + return rc.readStepResult(dest, rv, filled) + } + + if rc.stopCancellation == nil { + if rc.ctx.Done() == nil { + rv := C._sqlite3_step_internal(rc.s.s) + return rc.readStepResult(dest, rv, false) + } + conn := rc.s.c + rc.stopCancellation = context.AfterFunc(rc.ctx, func() { + conn.interruptActiveRows(rc) + }) } - sema := make(chan struct{}) - var err error - go func() { - err = rc.nextSyncLocked(dest) - close(sema) - }() - select { - case <-sema: + if err := rc.ctx.Err(); err != nil { return err - case <-rc.ctx.Done(): - select { - case <-sema: // no need to interrupt - default: - // this is still racy and can be no-op if executed between sqlite3_* calls in nextSyncLocked. - C.sqlite3_interrupt(rc.s.c.db) - <-sema // ensure goroutine completed + } + rv := rc.stepCancellableLocked() + err := rc.readStepResult(dest, rv, false) + if ctxErr := rc.ctx.Err(); ctxErr != nil { + return ctxErr + } + return err +} + +// eagerFirstStepLocked performs the first step of a cached statement +// under the same cancellation rules as Next, records the post-step +// column count, and drops the statement's cached metadata when SQLite +// re-prepared it after a schema change. Note that this runs the first +// step at query time, so a data-modifying statement issued through +// Query executes even if Next is never called. +// bindAndFirstStepLocked binds the arguments and takes the statement's +// first step under the same cancellation rules as Next, records the +// post-step column count, and drops the statement's cached metadata +// when SQLite re-prepared it after a schema change. The common case +// (positional arguments of the standard types) runs reset, bind and +// step in a single CGO crossing. +func (rc *SQLiteRows) bindAndFirstStepLocked(args []driver.NamedValue) (C.int, error) { + s := rc.s + s.mu.Lock() + defer s.mu.Unlock() + + var cargs []C.sqlite3_go_col + fused := true + if len(args) > 0 { + if cap(s.cargs) < len(args) { + s.cargs = make([]C.sqlite3_go_col, len(args)) } - return rc.ctx.Err() + cargs = s.cargs[:len(args)] + fused = s.marshalFusedArgs(args, cargs) } + if !fused { + if err := s.bind(args); err != nil { + return 0, err + } + } + + if rc.ctx.Done() != nil && rc.stopCancellation == nil { + conn := s.c + rc.stopCancellation = context.AfterFunc(rc.ctx, func() { + conn.interruptActiveRows(rc) + }) + } + if err := rc.ctx.Err(); err != nil { + rc.stopWatchingCancellation() + return 0, err + } + var ncol, repreps, filled C.int + step := func() C.int { + if fused { + var argp *C.sqlite3_go_col + if len(cargs) > 0 { + argp = &cargs[0] + } + return C._sqlite3_bind_step_columns(s.s, argp, C.int(len(cargs)), &ncol, &repreps, s.colvals, C.int(s.colvalsCap), &filled) + } + return C._sqlite3_step_columns(s.s, &ncol, &repreps) + } + var rv C.int + if rc.ctx.Done() == nil { + rv = step() + } else { + rv = func() C.int { + rc.startStepping() + defer rc.finishStepping() + return step() + }() + } + if err := rc.ctx.Err(); err != nil { + rc.stopWatchingCancellation() + C._sqlite3_reset_clear(s.s) + return 0, err + } + if rv != C.SQLITE_ROW && rv != C.SQLITE_DONE { + rc.stopWatchingCancellation() + err := s.c.lastError() + C._sqlite3_reset_clear(s.s) + return 0, err + } + rc.nc = int32(ncol) + rc.pendingFilled = filled != 0 + if repreps != s.repreps { + s.repreps = repreps + s.metadata = nil + } + if rc.nc > 0 { + // s.mu is still held here; the statement-owned row buffer must + // only be touched under it. + if rc.nc > s.colvalsCap { + if s.colvals != nil { + C.free(unsafe.Pointer(s.colvals)) + } + s.colvals = (*C.sqlite3_go_col)(C.malloc(C.size_t(rc.nc) * C.size_t(unsafe.Sizeof(C.sqlite3_go_col{})))) + if s.colvals == nil { + s.colvalsCap = 0 + C._sqlite3_reset_clear(s.s) + return 0, errors.New("sqlite3: failed to allocate row buffer") + } + s.colvalsCap = rc.nc + } + rc.colvals = s.colvals + } + return rv, nil } -// nextSyncLocked moves cursor to next; must be called with locked mutex. -func (rc *SQLiteRows) nextSyncLocked(dest []driver.Value) error { - rv := C._sqlite3_step_internal(rc.s.s) +func (rc *SQLiteRows) stepCancellableLocked() C.int { + rc.startStepping() + defer rc.finishStepping() + return C._sqlite3_step_internal(rc.s.s) +} + +func (rc *SQLiteRows) readStepResult(dest []driver.Value, rv C.int, filled bool) error { if rv == C.SQLITE_DONE { return io.EOF } @@ -2650,7 +3015,9 @@ if len(dest) == 0 { return nil } - C._sqlite3_column_values(rc.s.s, C.int(len(dest)), rc.colvals) + if !filled { + C._sqlite3_column_values(rc.s.s, C.int(len(dest)), rc.colvals) + } colvals := (*[(math.MaxInt32 - 1) / unsafe.Sizeof(C.sqlite3_go_col{})]C.sqlite3_go_col)(unsafe.Pointer(rc.colvals))[:len(dest):len(dest)] decltype := rc.decltype diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_func_crypt.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_func_crypt.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_func_crypt.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_func_crypt.go 2026-09-18 16:05:02.000000000 +0200 @@ -11,43 +11,41 @@ "crypto/sha512" ) -// This file provides several different implementations for the -// default embedded sqlite_crypt function. -// This function is uses a caesar-cypher by default -// and is used within the UserAuthentication module to encode -// the password. +// This file provides several different implementations for the default +// embedded sqlite_crypt function. This function uses a caesar-cypher by +// default and is used within the UserAuthentication module to encode the +// password. // // The provided functions can be used as an overload to the sqlite_crypt // function through the use of the RegisterFunc on the connection. // -// Because the functions can serv a purpose to an end-user -// without using the UserAuthentication module -// the functions are default compiled in. +// Because the functions can serve a purpose to an end-user without using the +// UserAuthentication module the functions are default compiled in. // // From SQLITE3 - user-auth.txt // The sqlite_user.pw field is encoded by a built-in SQL function -// "sqlite_crypt(X,Y)". The two arguments are both BLOBs. The first argument -// is the plaintext password supplied to the sqlite3_user_authenticate() -// interface. The second argument is the sqlite_user.pw value and is supplied +// "sqlite_crypt(X,Y)". The two arguments are both BLOBs. The first argument is +// the plain-text password supplied to the sqlite3_user_authenticate() +// interface. The second argument is the sqlite_user.pw value and is supplied // so that the function can extract the "salt" used by the password encoder. -// The result of sqlite_crypt(X,Y) is another blob which is the value that -// ends up being stored in sqlite_user.pw. To verify credentials X supplied -// by the sqlite3_user_authenticate() routine, SQLite runs: +// The result of sqlite_crypt(X,Y) is another blob which is the value that ends +// up being stored in sqlite_user.pw. To verify credentials X supplied by the +// sqlite3_user_authenticate() routine, SQLite runs: // // sqlite_user.pw == sqlite_crypt(X, sqlite_user.pw) // // To compute an appropriate sqlite_user.pw value from a new or modified -// password X, sqlite_crypt(X,NULL) is run. A new random salt is selected -// when the second argument is NULL. +// password X, sqlite_crypt(X,NULL) is run. A new random salt is selected when +// the second argument is NULL. // -// The built-in version of of sqlite_crypt() uses a simple Caesar-cypher -// which prevents passwords from being revealed by searching the raw database -// for ASCII text, but is otherwise trivally broken. For better password -// security, the database should be encrypted using the SQLite Encryption -// Extension or similar technology. Or, the application can use the -// sqlite3_create_function() interface to provide an alternative -// implementation of sqlite_crypt() that computes a stronger password hash, -// perhaps using a cryptographic hash function like SHA1. +// The built-in version of of sqlite_crypt() uses a simple Caesar-cypher which +// prevents passwords from being revealed by searching the raw database for +// ASCII text, but is otherwise trivally broken. For better password security, +// the database should be encrypted using the SQLite Encryption Extension or +// similar technology. Or, the application can use the +// sqlite3_create_function() interface to provide an alternative implementation +// of sqlite_crypt() that computes a stronger password hash, perhaps using a +// cryptographic hash function like SHA1. // CryptEncoderSHA1 encodes a password with SHA1 func CryptEncoderSHA1(pass []byte, hash any) []byte { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_libsqlite3.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_libsqlite3.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_libsqlite3.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_libsqlite3.go 2026-09-18 16:05:02.000000000 +0200 @@ -4,7 +4,6 @@ // license that can be found in the LICENSE file. //go:build libsqlite3 -// +build libsqlite3 package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_load_extension_omit.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_load_extension_omit.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_load_extension_omit.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_load_extension_omit.go 2026-09-18 16:05:02.000000000 +0200 @@ -4,7 +4,6 @@ // license that can be found in the LICENSE file. //go:build sqlite_omit_load_extension -// +build sqlite_omit_load_extension package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_allow_uri_authority.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_allow_uri_authority.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_allow_uri_authority.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_allow_uri_authority.go 2026-09-18 16:05:02.000000000 +0200 @@ -5,7 +5,6 @@ // license that can be found in the LICENSE file. //go:build sqlite_allow_uri_authority -// +build sqlite_allow_uri_authority package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_app_armor.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_app_armor.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_app_armor.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_app_armor.go 2026-09-18 16:05:02.000000000 +0200 @@ -5,7 +5,6 @@ // license that can be found in the LICENSE file. //go:build !windows && sqlite_app_armor -// +build !windows,sqlite_app_armor package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_dbstat.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_dbstat.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_dbstat.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_dbstat.go 2026-09-18 16:05:02.000000000 +0200 @@ -5,7 +5,6 @@ // license that can be found in the LICENSE file. //go:build sqlite_dbstat -// +build sqlite_dbstat package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_foreign_keys.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_foreign_keys.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_foreign_keys.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_foreign_keys.go 2026-09-18 16:05:02.000000000 +0200 @@ -5,7 +5,6 @@ // license that can be found in the LICENSE file. //go:build sqlite_foreign_keys -// +build sqlite_foreign_keys package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_fts5.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_fts5.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_fts5.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_fts5.go 2026-09-18 16:05:02.000000000 +0200 @@ -4,7 +4,6 @@ // license that can be found in the LICENSE file. //go:build sqlite_fts5 || fts5 -// +build sqlite_fts5 fts5 package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_icu.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_icu.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_icu.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_icu.go 2026-09-18 16:05:02.000000000 +0200 @@ -4,7 +4,6 @@ // license that can be found in the LICENSE file. //go:build sqlite_icu || icu -// +build sqlite_icu icu package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_introspect.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_introspect.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_introspect.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_introspect.go 2026-09-18 16:05:02.000000000 +0200 @@ -5,7 +5,6 @@ // license that can be found in the LICENSE file. //go:build sqlite_introspect -// +build sqlite_introspect package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_math_functions.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_math_functions.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_math_functions.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_math_functions.go 2026-09-18 16:05:02.000000000 +0200 @@ -4,7 +4,6 @@ // license that can be found in the LICENSE file. //go:build sqlite_math_functions -// +build sqlite_math_functions package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_os_trace.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_os_trace.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_os_trace.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_os_trace.go 2026-09-18 16:05:02.000000000 +0200 @@ -4,7 +4,6 @@ // license that can be found in the LICENSE file. //go:build sqlite_os_trace -// +build sqlite_os_trace package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_percentile.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_percentile.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_percentile.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_percentile.go 2026-09-18 16:05:02.000000000 +0200 @@ -5,7 +5,6 @@ // license that can be found in the LICENSE file. //go:build sqlite_percentile -// +build sqlite_percentile package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_preupdate.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_preupdate.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_preupdate.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_preupdate.go 2026-09-18 16:05:02.000000000 +0200 @@ -5,7 +5,6 @@ // license that can be found in the LICENSE file. //go:build cgo -// +build cgo package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_secure_delete.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_secure_delete.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_secure_delete.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_secure_delete.go 2026-09-18 16:05:02.000000000 +0200 @@ -5,7 +5,6 @@ // license that can be found in the LICENSE file. //go:build sqlite_secure_delete -// +build sqlite_secure_delete package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_secure_delete_fast.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_secure_delete_fast.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_secure_delete_fast.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_secure_delete_fast.go 2026-09-18 16:05:02.000000000 +0200 @@ -5,7 +5,6 @@ // license that can be found in the LICENSE file. //go:build sqlite_secure_delete_fast -// +build sqlite_secure_delete_fast package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_serialize_omit.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_serialize_omit.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_serialize_omit.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_serialize_omit.go 2026-09-18 16:05:02.000000000 +0200 @@ -1,5 +1,4 @@ //go:build libsqlite3 && !sqlite_serialize -// +build libsqlite3,!sqlite_serialize package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_stat4.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_stat4.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_stat4.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_stat4.go 2026-09-18 16:05:02.000000000 +0200 @@ -5,7 +5,6 @@ // license that can be found in the LICENSE file. //go:build sqlite_stat4 -// +build sqlite_stat4 package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_unlock_notify.go 2026-09-18 16:05:02.000000000 +0200 @@ -4,7 +4,6 @@ // license that can be found in the LICENSE file. //go:build cgo && sqlite_unlock_notify -// +build cgo,sqlite_unlock_notify package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_userauth.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_userauth.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_userauth.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_userauth.go 2026-09-18 16:05:02.000000000 +0200 @@ -4,7 +4,6 @@ // license that can be found in the LICENSE file. //go:build sqlite_userauth -// +build sqlite_userauth package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vacuum_full.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vacuum_full.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vacuum_full.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vacuum_full.go 2026-09-18 16:05:02.000000000 +0200 @@ -5,7 +5,6 @@ // license that can be found in the LICENSE file. //go:build sqlite_vacuum_full -// +build sqlite_vacuum_full package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vacuum_incr.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vacuum_incr.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vacuum_incr.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vacuum_incr.go 2026-09-18 16:05:02.000000000 +0200 @@ -5,7 +5,6 @@ // license that can be found in the LICENSE file. //go:build sqlite_vacuum_incr -// +build sqlite_vacuum_incr package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vtable.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vtable.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vtable.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_opt_vtable.go 2026-09-18 16:05:02.000000000 +0200 @@ -4,7 +4,6 @@ // license that can be found in the LICENSE file. //go:build sqlite_vtable || vtable -// +build sqlite_vtable vtable package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_solaris.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_solaris.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_solaris.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_solaris.go 2026-09-18 16:05:02.000000000 +0200 @@ -4,7 +4,6 @@ // license that can be found in the LICENSE file. //go:build solaris -// +build solaris package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_sql.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_sql.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_sql.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_sql.go 2026-09-18 16:05:02.000000000 +0200 @@ -4,7 +4,6 @@ // license that can be found in the LICENSE file. //go:build cgo -// +build cgo package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_usleep_windows.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_usleep_windows.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_usleep_windows.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_usleep_windows.go 2026-09-18 16:05:02.000000000 +0200 @@ -4,7 +4,6 @@ // license that can be found in the LICENSE file. //go:build cgo -// +build cgo package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/sqlite3_windows.go new/vendor/github.com/mattn/go-sqlite3/sqlite3_windows.go --- old/vendor/github.com/mattn/go-sqlite3/sqlite3_windows.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/sqlite3_windows.go 2026-09-18 16:05:02.000000000 +0200 @@ -4,7 +4,6 @@ // license that can be found in the LICENSE file. //go:build windows -// +build windows package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/github.com/mattn/go-sqlite3/static_mock.go new/vendor/github.com/mattn/go-sqlite3/static_mock.go --- old/vendor/github.com/mattn/go-sqlite3/static_mock.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/github.com/mattn/go-sqlite3/static_mock.go 2026-09-18 16:05:02.000000000 +0200 @@ -4,7 +4,6 @@ // license that can be found in the LICENSE file. //go:build !cgo -// +build !cgo package sqlite3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/google.golang.org/grpc/internal/transport/http2_server.go new/vendor/google.golang.org/grpc/internal/transport/http2_server.go --- old/vendor/google.golang.org/grpc/internal/transport/http2_server.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/google.golang.org/grpc/internal/transport/http2_server.go 2026-09-18 16:05:02.000000000 +0200 @@ -522,6 +522,12 @@ delete(mdata, "host") } + // If :authority is still missing, i.e. no host or :authority header is + // present, reject the request as invalid. + if len(mdata[":authority"]) == 0 { + t.writeEarlyAbort(streamID, s.contentSubtype, status.New(codes.Internal, "no host or :authority header present"), http.StatusBadRequest, !frame.StreamEnded()) + return nil + } if frame.StreamEnded() { // s is just created by the caller. No lock needed. s.state = streamReadDone diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/google.golang.org/grpc/version.go new/vendor/google.golang.org/grpc/version.go --- old/vendor/google.golang.org/grpc/version.go 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/google.golang.org/grpc/version.go 2026-09-18 16:05:02.000000000 +0200 @@ -19,4 +19,4 @@ package grpc // Version is the current grpc version. -const Version = "1.83.1" +const Version = "1.83.2" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/vendor/modules.txt new/vendor/modules.txt --- old/vendor/modules.txt 2026-09-04 04:11:36.000000000 +0200 +++ new/vendor/modules.txt 2026-09-18 16:05:02.000000000 +0200 @@ -240,7 +240,7 @@ # github.com/mattn/go-runewidth v0.0.28 ## explicit; go 1.23 github.com/mattn/go-runewidth -# github.com/mattn/go-sqlite3 v1.14.50 => github.com/rqlite/go-sqlite3 v1.50.0 +# github.com/mattn/go-sqlite3 v1.14.50 => github.com/rqlite/go-sqlite3 v1.51.0 ## explicit; go 1.21 github.com/mattn/go-sqlite3 # github.com/mitchellh/go-homedir v1.1.0 @@ -430,7 +430,7 @@ ## explicit; go 1.25.0 google.golang.org/genproto/googleapis/rpc/errdetails google.golang.org/genproto/googleapis/rpc/status -# google.golang.org/grpc v1.83.1 +# google.golang.org/grpc v1.83.2 ## explicit; go 1.25.0 google.golang.org/grpc google.golang.org/grpc/attributes @@ -542,4 +542,4 @@ google.golang.org/protobuf/types/known/timestamppb google.golang.org/protobuf/types/known/wrapperspb # github.com/armon/go-metrics => github.com/hashicorp/go-metrics v0.5.1 -# github.com/mattn/go-sqlite3 => github.com/rqlite/go-sqlite3 v1.50.0 +# github.com/mattn/go-sqlite3 => github.com/rqlite/go-sqlite3 v1.51.0
