dependabot[bot] opened a new pull request, #4404: URL: https://github.com/apache/arrow-adbc/pull/4404
Bumps [modernc.org/sqlite](https://gitlab.com/cznic/sqlite) from 1.51.0 to 1.52.0. <details> <summary>Changelog</summary> <p><em>Sourced from <a href="https://gitlab.com/cznic/sqlite/blob/master/CHANGELOG.md";>modernc.org/sqlite's changelog</a>.</em></p> <blockquote> <h1>Changelog</h1> <ul> <li> <p>2026-06-14 v1.53.0:</p> <ul> <li>Add <strong>experimental</strong> <code>netbsd/amd64</code> support, resolving the long-standing build break in [GitLab issue <a href="https://gitlab.com/cznic/sqlite/issues/246";>#246</a>](<a href="https://gitlab.com/cznic/sqlite/-/issues/246";>https://gitlab.com/cznic/sqlite/-/issues/246</a>). This target is intentionally <strong>not yet listed among the supported platforms</strong> in the package documentation: the port had been broken for years and is only now revived, and there is as yet no real-world experience running it under production workloads. Green CI is not the same as battle-tested — so while the full test suite (including the <code>pcache</code> and <code>vec</code> packages and the <code>-race</code> concurrency test) passes on NetBSD 10.1 / Go 1.26.3, and the entire upstream toolchain (<code>libc</code>, <code>cc</code>, <code>ccgo</code>, <code>libz</code>, <code>libtcl8.6</code>, <code>libsqlite3</code>, <code>libsqlite_vec</code>) is green on the NetBSD CI builder, the target is offered for evaluation only. If you run NetBSD, please exercise it with your own workloads and report back via <a href="https://gitlab.com/cznic/sqlite/issues/246";>#246</a>; the intent is to promote it to a fully supported platform after a period of broader real-world testing (on the order of a month) elapses without surprises.</li> <li>Implementation notes: the previously shipped <code>lib/sqlite_netbsd_amd64.go</code> was a stale old-generator transpile that no longer compiled (the <code>mu.enter</code>/<code>mu.leave</code> break in <a href="https://gitlab.com/cznic/sqlite/issues/246";>#246</a>); it is replaced by a fresh new-generator transpile consistent with every other platform, and <code>modernc.org/sqlite/vec</code> (sqlite-vec) is vendored and auto-registers on netbsd. Correct operation requires the matching pinned <code>modernc.org/libc</code>, which carries two NetBSD-specific fixes found during this work: the <code>mmap(2)</code> <code>PAD</code>-argument ABI (without it, concurrent WAL access faults with SIGBUS in the WAL-index shared memory) and a working <code>abort(3)</code> (the prior stub left SQLite's crash-recovery <code>writecrash</code> test unable to terminate by signal). As usual, downstream modules must pin the exact <code>modernc.org/libc</code> version this module's <code>go.mod</co de> pins.</li> <li>See [GitLab merge request <a href="https://gitlab.com/cznic/sqlite/issues/82";>#82</a>](<a href="https://gitlab.com/cznic/sqlite/-/merge_requests/82";>https://gitlab.com/cznic/sqlite/-/merge_requests/82</a>), thanks Leonardo Taccari (<a href="https://github.com/iamleot";><code>@iamleot</code></a>) and Thomas Klausner (@<em>wiz</em>)!</li> <li>Add a Go-facing wrapper for <code>SQLITE_CONFIG_PCACHE2</code>. <code>PageCache</code> is the factory and <code>Cache</code> the per-database instance, both idiomatic Go interfaces; <code>Page</code> exposes the raw <code>Buf</code> and <code>Extra</code> pointers that SQLite reads through the C pcache contract. <code>RegisterPageCache</code> and <code>MustRegisterPageCache</code> install the module process-globally before the first <code>sql.Open</code>; subsequent Open calls are gated through a one-shot <code>Xsqlite3_config(SQLITE_CONFIG_PCACHE2)</code> so a too-late Register returns <code>ErrPageCacheTooLate</code> rather than silently falling through to the built-in pcache1. The binding owns the <code>sqlite3_pcache_page</code> stub and re-consults the implementation on every Fetch, reusing the stub only when the returned <code>Page</code> value is unchanged, which keeps a bounded/evicting purgeable cache safe by construction.</li> <li>See [GitLab merge request <a href="https://gitlab.com/cznic/sqlite/issues/126";>#126</a>](<a href="https://gitlab.com/cznic/sqlite/-/merge_requests/126";>https://gitlab.com/cznic/sqlite/-/merge_requests/126</a>), thanks Ian Chechin!</li> <li>Add <code>modernc.org/sqlite/pcache</code>, the reference page-cache implementation that accompanies the <a href="https://gitlab.com/cznic/sqlite/issues/126";>#126</a> <code>SQLITE_CONFIG_PCACHE2</code> wrapper. <code>pcache.New</code> returns a <code>*Pool</code> satisfying the <code>PageCache</code> interface; register it once with <code>sqlite.MustRegisterPageCache(pcache.New())</code> and every connection opened afterwards draws its pages from it. Each <code>Pool.Create</code> mints a fresh per-database <code>Cache</code>: a bounded, LRU-evicting page store that honours the <code>PRAGMA cache_size</code> soft cap and releases the least-recently-unpinned page when it must make room. Page memory — the <code>Buf</code> and <code>Extra</code> buffers SQLite reads through — is allocated with <code>libc.Xmalloc</code>/<code>libc.Xcalloc</code> and therefore lives off the Go heap, which keeps SQLite's interior pointer arithmetic on the page extras from tripping the race detect or's checkptr enforcement. <code>Pool.Stats</code> reports aggregate lifetime counters (hits, misses, allocs, evictions, rekeys, truncates, caches) across every cache a Pool has created, so hit/miss/eviction behaviour is observable without instrumenting individual caches. Cross-connection page sharing is out of scope for now; each <code>Create</code> returns an independent per-database cache.</li> <li>Validated end-to-end against the <a href="https://gitlab.com/cznic/sqlite/issues/126";>#126</a> stress workload (<code>cache_size=16</code>, 4000 BLOB rows with DELETE and <code>incremental_vacuum</code>, <code>integrity_check</code> clean under <code>-race</code>) and benchmarked for the memory-utilization goal tracked in [GitLab issue <a href="https://gitlab.com/cznic/sqlite/issues/204";>#204</a>](<a href="https://gitlab.com/cznic/sqlite/-/issues/204";>https://gitlab.com/cznic/sqlite/-/issues/204</a>).</li> <li>See [GitLab merge request <a href="https://gitlab.com/cznic/sqlite/issues/127";>#127</a>](<a href="https://gitlab.com/cznic/sqlite/-/merge_requests/127";>https://gitlab.com/cznic/sqlite/-/merge_requests/127</a>), thanks Ian Chechin!</li> <li>Tighten the <code>modernc.org/sqlite/pcache</code> reference implementation per cznic's !127 review follow-ups. Adds <code>Stats.EasyRefusals</code>, a per-Pool counter for the cases where <code>FetchCreateEasy</code> returns nil at cap; SQLite reacts to a refusal by spilling dirty pages and retrying with <code>FetchCreateForce</code>, so the new field is a direct proxy for the I/O pressure the strict Easy contract imposes vs pcache1's recycle-without-spill behavior. <code>BenchmarkPoolEvictionChurn</code> was reworked to drive a rotating-residue DELETE (<code>k % 3 = i % 3</code>) and re-insert a matching batch each cycle so the spill pressure recurs and <code>easy-refusals/op</code> scales with <code>b.N</code> instead of capping at the seed's one-time first-cycle cost; both existing benchmarks now report <code>easy-refusals/op</code> alongside the page-allocs/evictions metrics. <code>Stats.Evictions</code> documentation was tightened to match the actual behavior (counts LRU eviction, <code>Unpin(discard=true)</code>, <code>Shrink</code> releases, and <code>Unpin(discard=false)</code> trimming back to target after a <code>FetchCreateForce</code> overcommit; bulk frees from <code>Truncate</code>, <code>Rekey</code> collisions, and <code>Destroy</code> are not counted). The <code>TestPoolRoundTripIntegrity</code> comment claiming the workload exercises <code>xRekey</code> ~15 times has been corrected; the SQL surface does not reliably emit xRekey here, and that codepath is covered by the unit tests instead.</li> <li>See [GitLab merge request <a href="https://gitlab.com/cznic/sqlite/issues/130";>#130</a>](<a href="https://gitlab.com/cznic/sqlite/-/merge_requests/130";>https://gitlab.com/cznic/sqlite/-/merge_requests/130</a>), thanks Ian Chechin!</li> <li>Make <code>modernc.org/sqlite/pcache</code> <code>-race</code>-clean under SQLite's <code>cache=shared</code> mode. The pool already runs correctly under shared-cache because every callback into a given <code>Cache</code> is serialised internally by SQLite's <code>sqlite3BtreeEnter</code> on the <code>BtShared</code> mutex; verified empirically with a lock-free in-flight probe (max-in-flight = 1 on the canonical two-connection workload, 4 on a positive control with goroutines hitting the cache directly). However the Go race detector does not recognise SQLite's libc mutex as a happens-before edge and reports false-positive races on <code>Fetch</code> vs <code>Unpin</code> reads/writes of the per-cache state, which surfaces as <code>DATA RACE</code> failures for any user who registers the pool and runs their suite under <code>-race</code>. A <code>sync.Mutex</code> on the <code>cache</code> type is now taken on every public method (<code>SetSize</code>, <code>PageCount</code>, < code>Fetch</code>, <code>Unpin</code>, <code>Rekey</code>, <code>Truncate</code>, <code>Destroy</code>, <code>Shrink</code>), always. On the common non-shared-cache path the lock is uncontended (one atomic CAS per Lock/Unlock pair, negligible next to the SQLite work it bookends); on the shared-cache path it just rubber-stamps the order SQLite's <code>BtShared</code> mutex already established. A new <code>e2e_test.go</code> <code>TestSharedCacheTwoConns_Integrity</code> drives two <code>sql.Conn</code> against the same <code>cache=shared</code> URI with concurrent writers and asserts <code>PRAGMA integrity_check = ok</code> under <code>-race</code>; passes cleanly with the lock, would surface the false-positive without it. Design notes live in <code>pcache/sharing.go</code>.</li> <li>See [GitLab merge request <a href="https://gitlab.com/cznic/sqlite/issues/131";>#131</a>](<a href="https://gitlab.com/cznic/sqlite/-/merge_requests/131";>https://gitlab.com/cznic/sqlite/-/merge_requests/131</a>), thanks Ian Chechin!</li> <li>Add a Go wrapper for <code>sqlite3_db_status</code>, the per-connection runtime counters (cache hit/miss/write/spill rates, schema and prepared-statement memory, lookaside usage, deferred foreign keys). <code>DBStatus</code> is an interface implemented by the driver connection and reached through the <code>database/sql</code> escape hatch <code>(*sql.Conn).Raw()</code>, mirroring the existing <code>FileControl</code> surface; <code>DBStatusOp</code> is a distinct typed enum of the <code>SQLITE_DBSTATUS_*</code> verbs so a counter from a different op family will not compile in its place. <code>Status(op, reset)</code> returns the <code>(current, high)</code> pair and optionally resets the counter. This also lets <code>modernc.org/sqlite/pcache</code> measure real I/O instead of the <code>EasyRefusals</code> proxy: the new <code>BenchmarkPoolSpillIO</code> reads the pager-level <code>SQLITE_DBSTATUS_CACHE_SPILL</code>/<code>_CACHE_WRITE</code> counters, which the pager maintains identically for pcache1 and the pool, making the pcache1-vs-pool comparison cznic raised on the !127 review a genuine apples-to-apples measurement. On the rotating-residue eviction-churn workload at <code>cache_size=16</code> the pool spills ~3.5x more than pcache1 (cache-spill/op 31.96 vs 8.96) for ~3% more page writes (cache-write/op 450 vs 436) at identical hit/miss, quantifying the I/O cost of the strict Easy contract that <code>EasyRefusals</code> only proxied.</li> <li>See [GitLab merge request <a href="https://gitlab.com/cznic/sqlite/issues/132";>#132</a>](<a href="https://gitlab.com/cznic/sqlite/-/merge_requests/132";>https://gitlab.com/cznic/sqlite/-/merge_requests/132</a>), thanks Ian Chechin!</li> <li>Add an opt-in <code>_dqs</code> DSN query parameter that disables SQLite's double-quoted string literal compatibility quirk on a per-connection basis. When <code>_dqs=0</code> (or any <code>strconv.ParseBool</code> false value) is supplied, the driver calls <code>sqlite3_db_config</code> with <code>SQLITE_DBCONFIG_DQS_DDL</code> and <code>SQLITE_DBCONFIG_DQS_DML</code> set to off before any statement is prepared, so a double-quoted identifier that fails to resolve raises a parse error instead of silently falling back to a string literal. Absence of the parameter, or <code>_dqs=1</code>, leaves SQLite's default behavior unchanged; existing DSNs continue to work byte-for-byte. Resolves [GitLab issue <a href="https://gitlab.com/cznic/sqlite/issues/61";>#61</a>](<a href="https://gitlab.com/cznic/sqlite/-/issues/61";>https://gitlab.com/cznic/sqlite/-/issues/61</a>).</li> <li>See [GitLab merge request <a href="https://gitlab.com/cznic/sqlite/issues/128";>#128</a>](<a href="https://gitlab.com/cznic/sqlite/-/merge_requests/128";>https://gitlab.com/cznic/sqlite/-/merge_requests/128</a>), thanks Ian Chechin!</li> <li>Add an opt-in <code>_error_rc</code> DSN query parameter for clearer error reporting on open-time failures. When <code>_error_rc=1</code> (or any <code>strconv.ParseBool</code> true value) is supplied, error strings synthesised from a <code>(rc, db)</code> pair only append <code>sqlite3_errmsg(db)</code> when <code>sqlite3_extended_errcode(db)</code> is consistent with the operation rc (full match first, primary code <code>&0xff</code> as fallback). On mismatch the canonical <code>sqlite3_errstr(rc)</code> is used alone, so an open-time <code>SQLITE_CANTOPEN</code> no longer carries the temporary handle's stale "out of memory" errmsg. Absence of the parameter, or <code>_error_rc=0</code>, preserves the legacy "errstr: errmsg" form byte-for-byte; existing callers that parse error strings are unaffected. The driver's <code>*Error.Code()</code> returns the same SQLite result code in both modes. Parsed before <code>sqlite3_open_v2</code> so open-time errors are covered. Resolves [GitLab issue <a href="https://gitlab.com/cznic/sqlite/issues/230";>#230</a>](<a href="https://gitlab.com/cznic/sqlite/-/issues/230";>https://gitlab.com/cznic/sqlite/-/issues/230</a>).</li> <li>See [GitLab merge request <a href="https://gitlab.com/cznic/sqlite/issues/129";>#129</a>](<a href="https://gitlab.com/cznic/sqlite/-/merge_requests/129";>https://gitlab.com/cznic/sqlite/-/merge_requests/129</a>), thanks Ian Chechin!</li> </ul> </li> <li> <p>2026-06-06 v1.52.0:</p> <ul> <li>Upgrade to <a href="https://sqlite.org/releaselog/3_53_2.html";>SQLite 3.53.2</a>.</li> <li>Add <code>Backup.Remaining</code> and <code>Backup.PageCount</code>, thin wrappers around the existing <code>sqlite3_backup_remaining</code> and <code>sqlite3_backup_pagecount</code> C symbols. Together they expose the per-<code>Step</code> progress counters that the underlying backup object already maintains, enabling progress reporting during online backups without dropping to <code>modernc.org/sqlite/lib</code> directly.</li> <li>See [GitLab merge request <a href="https://gitlab.com/cznic/sqlite/issues/122";>#122</a>](<a href="https://gitlab.com/cznic/sqlite/-/merge_requests/122";>https://gitlab.com/cznic/sqlite/-/merge_requests/122</a>), thanks Ian Chechin!</li> <li>Drop the redundant second copy in <code>(*conn).columnText</code>, the path that backs every <code>Rows.Scan</code> into a Go <code>string</code> for a TEXT column. The value's bytes are still copied once out of SQLite-owned memory into a fresh Go buffer; that buffer is then reinterpreted as the result string with <code>unsafe.String</code> rather than copied a second time by the implicit <code>string([]byte)</code> conversion. This removes one allocation per TEXT value per row and roughly halves the bytes allocated on that path; on the new <code>BenchmarkColumnTextScan</code> cases it is ~13–20% faster for payloads of 256 B and larger, with no measurable change for very short strings. Purely internal: no API or behavioral change, and the returned string never aliases SQLite's buffer.</li> <li>See [GitLab merge request <a href="https://gitlab.com/cznic/sqlite/issues/123";>#123</a>](<a href="https://gitlab.com/cznic/sqlite/-/merge_requests/123";>https://gitlab.com/cznic/sqlite/-/merge_requests/123</a>), thanks Ian Chechin!</li> <li>Cache each result column's declared type once per result set in <code>newRows</code> instead of recomputing it on every row. The TEXT branch of <code>Rows.Next</code> calls <code>ColumnTypeDatabaseTypeName</code> for every TEXT column on every row (independent of any DSN flag), which previously did a <code>libc.GoString</code> + <code>strings.ToUpper</code> each time; that lookup is now a single index into a cached, pre-uppercased <code>[]string</code>, and <code>ColumnTypeScanType</code> reads the same cache and drops its per-call <code>strings.ToLower</code>. The declared type is fixed for the lifetime of a prepared statement, so the C round-trip is paid once per column rather than once per column per row, removing exactly 1 alloc + 8 B per TEXT column per row from the <code>Next</code> hot path. The new <code>BenchmarkTextToTimeScan</code> cases show ~7% faster on a 1000-row DATETIME SELECT under <code>_texttotime=1</code>. Purely internal: <code>ColumnTypeDatabaseTypeName< /code> and <code>ColumnTypeScanType</code> return identical values, no API or behavioral change.</li> <li>See [GitLab merge request <a href="https://gitlab.com/cznic/sqlite/issues/124";>#124</a>](<a href="https://gitlab.com/cznic/sqlite/-/merge_requests/124";>https://gitlab.com/cznic/sqlite/-/merge_requests/124</a>), thanks Ian Chechin!</li> <li>Cache, per result column, the <code>parseTimeFormats</code> index that first parsed a TEXT-stored DATE/DATETIME/TIMESTAMP value, and try that format first on later rows instead of re-walking the list from the top. <code>(*conn).parseTime</code> previously ran <code>time.Parse</code> down the format list on every such row; for the canonical SQLite TEXT datetime format every row paid two failed <code>time.Parse</code> attempts — each allocating a <code>*time.ParseError</code> — before the match. On a 1000-row DATETIME TEXT SELECT this cuts ~50% of allocs/op and ~57% of B/op and is ~37% faster. The fall-through chain is preserved exactly: the seven formats are mutually exclusive, so the cached hint can never select a different match than the in-order scan, and the parsed <code>driver.Value</code> is identical to before. Purely internal: no API or behavioral change.</li> <li>See [GitLab merge request <a href="https://gitlab.com/cznic/sqlite/issues/125";>#125</a>](<a href="https://gitlab.com/cznic/sqlite/-/merge_requests/125";>https://gitlab.com/cznic/sqlite/-/merge_requests/125</a>), thanks Ian Chechin!</li> </ul> </li> <li> <p>2026-05-28 v1.51.0:</p> <ul> <li>Pool the <code>[]driver.Value</code> slice passed to scalar/aggregate UDF callbacks and to vtab <code>Filter</code>/<code>Insert</code>/<code>Update</code> callbacks, eliminating the dominant per-row allocation on UDF-heavy queries. Benchmarks on a 1000-row, 3-arg noop scalar UDF show ~40% fewer bytes/op and ~15% fewer allocs/op.</li> <li>Document the matching "arguments are not valid past return" contract on <code>vtab.Cursor.Filter</code> and <code>vtab.Updater.Insert</code>/<code>Update</code>, consistent with the existing rule for <code>FunctionImpl.Scalar</code> / <code>AggregateFunction.Step</code> / <code>WindowInverse</code>.</li> <li>Resolves [GitLab issue <a href="https://gitlab.com/cznic/sqlite/issues/226";>#226</a>](<a href="https://gitlab.com/cznic/sqlite/-/issues/226";>https://gitlab.com/cznic/sqlite/-/issues/226</a>). See [GitLab merge request <a href="https://gitlab.com/cznic/sqlite/issues/114";>#114</a>](<a href="https://gitlab.com/cznic/sqlite/-/merge_requests/114";>https://gitlab.com/cznic/sqlite/-/merge_requests/114</a>), thanks Ian Chechin!</li> <li>Add <code>FileControl.FileControlDataVersion</code>, a wrapper around <code>SQLITE_FCNTL_DATA_VERSION</code> for observing pager-cache data-version changes, including those made on the same connection. Useful as a primitive for application-level cache invalidation.</li> <li>Exposed via the idiomatic <code>database/sql</code> escape hatch <code>(*sql.Conn).Raw()</code>, consistent with the existing <code>FileControlPersistWAL</code>.</li> <li>See [GitLab merge request <a href="https://gitlab.com/cznic/sqlite/issues/115";>#115</a>](<a href="https://gitlab.com/cznic/sqlite/-/merge_requests/115";>https://gitlab.com/cznic/sqlite/-/merge_requests/115</a>), thanks Ian Chechin!</li> <li>Fix a regression where in-memory connections (<code>:memory:</code>, <code>file::memory:</code>, shared-cache memory URIs) were discarded by <code>database/sql</code> after a context-cancelled query, taking the entire in-memory store with them. The fix for <a href="https://gitlab.com/cznic/sqlite/issues/198";>#198</a> had added an <code>sqlite3_is_interrupted</code> check to the connection validator that mistakenly applied to in-memory connections too, re-introducing the bug originally fixed by !74. File-backed connections keep the existing behaviour and are still discarded after an interrupt.</li> <li>Resolves [GitLab issue <a href="https://gitlab.com/cznic/sqlite/issues/196";>#196</a>](<a href="https://gitlab.com/cznic/sqlite/-/issues/196";>https://gitlab.com/cznic/sqlite/-/issues/196</a>). See [GitLab merge request <a href="https://gitlab.com/cznic/sqlite/issues/116";>#116</a>](<a href="https://gitlab.com/cznic/sqlite/-/merge_requests/116";>https://gitlab.com/cznic/sqlite/-/merge_requests/116</a>), thanks Ian Chechin!</li> <li>Add an opt-in <code>FunctionImpl.VolatileArgs</code> flag that hands TEXT and BLOB arguments to scalar and aggregate UDF callbacks as zero-copy views (<code>unsafe.String</code>/<code>unsafe.Slice</code>) over SQLite's own value buffers, eliminating the per-argument <code>libc.GoString</code>/<code>make([]byte)</code> copy that the <a href="https://gitlab.com/cznic/sqlite/issues/226";>#226</a> slice-pooling left as the remaining per-row allocation. On the same 1000-row, 3-arg (INTEGER/TEXT/BLOB) noop scalar UDF this removes a further ~35% of allocs/op and ~11% of bytes/op on top of <a href="https://gitlab.com/cznic/sqlite/issues/226";>#226</a>.</li> <li>The views are valid only for the duration of the callback and must not be retained past return or across rows; a callback that needs to keep a value must copy it. With <code>VolatileArgs</code> unset (the default) arguments keep the existing copied, caller-owned semantics, so the flag is fully backward compatible; it has no effect on integer, float, time, or NULL arguments.</li> <li>See [GitLab merge request <a href="https://gitlab.com/cznic/sqlite/issues/120";>#120</a>](<a href="https://gitlab.com/cznic/sqlite/-/merge_requests/120";>https://gitlab.com/cznic/sqlite/-/merge_requests/120</a>), thanks Ian Chechin!</li> <li>Extend the opt-in <code>VolatileArgs</code> zero-copy TEXT/BLOB argument access from <a href="https://gitlab.com/cznic/sqlite/issues/120";>#120</a> to the virtual-table <code>Cursor.Filter</code> (<code>xFilter</code>) and <code>Updater.Insert</code>/<code>Update</code> (<code>xUpdate</code>) callbacks. A <code>vtab.Module</code> opts in by implementing the new optional <code>vtab.VolatileArgsOpter</code> interface (<code>VolatileArgs() bool</code>); the flag is read once at module registration and shared by every table created from it. On a vtab call carrying one TEXT and one BLOB argument this removes 2 allocs/op (one <code>libc.GoString</code>, one <code>make([]byte)</code>) on each of the Filter and Update paths.</li> <li>The same safety contract as <a href="https://gitlab.com/cznic/sqlite/issues/120";>#120</a> applies: the views are valid only for the duration of the callback and must not be retained past return or across rows; a callback that needs to keep a value must copy it. Modules that do not implement <code>VolatileArgsOpter</code> (the default for all existing modules) are byte-for-byte unchanged, and the flag has no effect on integer, float, time, or NULL arguments.</li> <li>See [GitLab merge request <a href="https://gitlab.com/cznic/sqlite/issues/121";>#121</a>](<a href="https://gitlab.com/cznic/sqlite/-/merge_requests/121";>https://gitlab.com/cznic/sqlite/-/merge_requests/121</a>), thanks Ian Chechin!</li> </ul> </li> <li> <p>2026-05-10 v1.50.1:</p> </li> </ul> <!-- raw HTML omitted --> </blockquote> <p>... (truncated)</p> </details> <details> <summary>Commits</summary> <ul> <li><a href="https://gitlab.com/cznic/sqlite/commit/66b4d20f42485b9823a2d35c86b08335d927d0e5";><code>66b4d20</code></a> release v1.52.0, upgrade to SQLite 3.53.2</li> <li><a href="https://gitlab.com/cznic/sqlite/commit/e3f64ec2f026880b2fbc868f195863648cd07fb3";><code>e3f64ec</code></a> rows: clarify parseFmtIdx mixed-column cost; CHANGELOG.md: document <a href="https://gitlab.com/cznic/sqlite/issues/125";>#125</a></li> <li><a href="https://gitlab.com/cznic/sqlite/commit/448579342c2da286622d7cab5db84a746124e7b1";><code>4485793</code></a> Merge branch 'perf/cache-parse-time-format' into 'master'</li> <li><a href="https://gitlab.com/cznic/sqlite/commit/3638d17bf28d730d7dd90ff5cf3f93c45b9d752e";><code>3638d17</code></a> rows: cache the parseTime format index per result column</li> <li><a href="https://gitlab.com/cznic/sqlite/commit/7da793ef16502dced14643451a8bec834f999d9e";><code>7da793e</code></a> CHANGELOG.md: document <a href="https://gitlab.com/cznic/sqlite/issues/124";>#124</a></li> <li><a href="https://gitlab.com/cznic/sqlite/commit/51e6714774262680e2454b1a9ccc49b4245b220a";><code>51e6714</code></a> Merge branch 'perf/cache-column-decltype' into 'master'</li> <li><a href="https://gitlab.com/cznic/sqlite/commit/8a6f33ce42bfa4a864daf8a4c97908e7691499d9";><code>8a6f33c</code></a> rows: lock down ColumnTypeScanType under the decltype cache</li> <li><a href="https://gitlab.com/cznic/sqlite/commit/f8fb6dd1d58d74d022b77cc385a9828a1ac49762";><code>f8fb6dd</code></a> rows: cache the column decltype lookup once per result set</li> <li><a href="https://gitlab.com/cznic/sqlite/commit/b17c0c7faf2247b8251efaa638ac101e5dea7ec1";><code>b17c0c7</code></a> CHANGELOG.md: document <a href="https://gitlab.com/cznic/sqlite/issues/123";>#123</a></li> <li><a href="https://gitlab.com/cznic/sqlite/commit/c80a08fbe3d37ffa8c7e669c46053b692135523b";><code>c80a08f</code></a> Merge branch 'perf/column-text-zero-copy' into 'master'</li> <li>Additional commits viewable in <a href="https://gitlab.com/cznic/sqlite/compare/v1.51.0...v1.52.0";>compare view</a></li> </ul> </details> <br /> [](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. [//]: # (dependabot-automerge-start) [//]: # (dependabot-automerge-end) --- <details> <summary>Dependabot commands and options</summary> <br /> You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself) </details> -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
