Repository navigation
chore(ci): bump the actions group across 1 directory with 3 updates - #145
Closed
dependabot[bot] wants to merge 1 commit into
Closed
dependabot[bot] wants to merge 1 commit into
dependabot[bot] wants to merge 1 commit into
Conversation
Contributor
Author
LabelsThe following labels could not be found: Please fix the above issues or remove invalid values from |
Bumps the actions group with 3 updates in the / directory: [dtolnay/rust-toolchain](https://github.com/dtolnay/rust-toolchain), [Swatinem/rust-cache](https://github.com/swatinem/rust-cache) and [rust-lang/crates-io-auth-action](https://github.com/rust-lang/crates-io-auth-action). Updates `dtolnay/rust-toolchain` from e2a55d2ffb04f378e9626c28d38b36d230d1e12f to 683b588c487a69d01f6c6ddf40f036ff682cc2c8 - [Release notes](https://github.com/dtolnay/rust-toolchain/releases) - [Commits](dtolnay/rust-toolchain@e2a55d2...683b588) Updates `Swatinem/rust-cache` from 2.9.2 to 2.9.3 - [Release notes](https://github.com/swatinem/rust-cache/releases) - [Changelog](https://github.com/Swatinem/rust-cache/blob/master/CHANGELOG.md) - [Commits](Swatinem/rust-cache@6323deb...d1527c8) Updates `rust-lang/crates-io-auth-action` from 1.0.5 to 1.0.6 - [Release notes](https://github.com/rust-lang/crates-io-auth-action/releases) - [Commits](rust-lang/crates-io-auth-action@c6f97d4...3268eb4) --- updated-dependencies: - dependency-name: dtolnay/rust-toolchain dependency-version: 683b588c487a69d01f6c6ddf40f036ff682cc2c8 dependency-type: direct:production dependency-group: actions - dependency-name: rust-lang/crates-io-auth-action dependency-version: 1.0.6 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: actions - dependency-name: Swatinem/rust-cache dependency-version: 2.9.3 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: actions ... Signed-off-by: dependabot[bot] <support@github.com>
dependabot
Bot
force-pushed
the
dependabot/github_actions/actions-37e66268e9
branch
from
October 29, 2026 12:13
7951922 to
d8249bb
Compare
tomtom215
pushed a commit
that referenced
this pull request
Oct 30, 2026
… against the workflows (DEPS-15) What was wrong: Dependabot #145 bumps three actions. Merged as is, it would (1) leave all 39 dtolnay/rust-toolchain lines commented `# master 2026-10-08` on a 2026-10-15 commit, and the ci.yml header naming the old commit; (2) leave the scaffold's own copies of the pins (src/scaffold/templates_ci.rs) on the old commits: nothing compared them with .github/workflows, so generated extension CIs would silently keep older actions (deps reviewer, DEPS-15). Change, every workflow: - Swatinem/rust-cache v2.9.2 -> v2.9.3 = d1527c8f67ef9af357290475d4af4b0fab8f12e0 (35 uses) - rust-lang/crates-io-auth-action v1.0.5 -> v1.0.6 = 3268eb413133e2960fa4ae0e963ca76380c54cd9 - dtolnay/rust-toolchain -> 683b588c487a69d01f6c6ddf40f036ff682cc2c8 (master HEAD, 2026-10-15), commented `# master` (41 uses): the branch has no tags and Dependabot moves the commit, so a date in the comment goes stale. - ci.yml header reworded so it stays true across those bumps. - scripts/check-action-pins.py, in the `doc` job: every remote `uses:` is a 40-hex commit; each action repository is pinned one way across all workflows (commit and the comment's first word); each pin in templates_ci.rs that names an action the workflows use must match; no pins found on either side is an error. - dependabot.yml: hello-ext gets no duckdb/libduckdb-sys ignore, on purpose, and says why: the example tracks the newest bindings (2.0's), unlike the MSRV-held root lock, and is where CI builds and loads them. Verified: `git ls-remote`: rust-cache refs/tags/v2.9.3^{} = d1527c8, crates-io-auth-action refs/tags/v1.0.6 = 3268eb4, dtolnay HEAD and master = 683b588. Upstream diffs read (shallow fetches): rust-cache 2.9.2..2.9.3 action.yml unchanged, src/ has three fixes (await, `return`->`continue` in timestamp pruning, a warning -> info), dist/ rebuilt (not rebuilt by me); crates-io-auth-action 1.0.5..1.0.6 action.yml unchanged, dependency/CI updates and dist/ rebuild; dtolnay e2a55d2..683b588 is one line in scripts/update-revs.sh (e2a55d2 is an ancestor). check-action-pins.py: on this branch alone exit 1, naming exactly the two stale scaffold pins (RUST_TOOLCHAIN, RUST_CACHE) with the strings to use; on a copy with them updated: exit 0, 139 uses, 12 repositories; probes (copy-based, $S/impl/infra/mut_pins.py): one use on another commit, a stale version comment, a floating tag, a scaffold pin differing, templates_ci.rs pins no longer parsing, release.yml on a tag -> all RED; a date after `master` and cache/restore+save -> GREEN. dependabot.yml validates against SchemaStore's dependabot-2.0 schema (jsonschema 4.26.0; 4 blocks, cooldown on all 4); a copy with a bad cooldown and an unknown key is rejected. actionlint clean; zizmor unchanged (52, default-visible 2).
tomtom215
pushed a commit
that referenced
this pull request
Oct 30, 2026
Merges the 19 commits of the infra implementation agent (eighth review): the upstream-guard wrapper, a hardened CI aggregate check, release-metadata and --locked dry-run checks, release.yml hardening (crate hash checked before upload), an actionlint job, a hygiene job (typos, taplo, machete, the deny matrix over the CI-only graphs), the exact toolchain pin with an informational latest-stable job, the Dependabot #145 action bumps, a corrected API-coverage script, SECURITY.md and RELEASING.md corrections, and the sanitizer blind-spot documentation. Details: AUDIT.md section 14. Known to fail until the scaffold and api work packages merge: check-action-pins.py (the scaffold's templates_ci.rs pins) and check-api-coverage.py (duckdb_open and duckdb_close are not yet in the allowlist). Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
14 of 16 tasks
tomtom215
added a commit
that referenced
this pull request
Oct 30, 2026
…150) * Fix the ListBuilder entry-array regression and five smaller issues found re-reviewing the seventh review ListBuilder (High, regression vs 0.19.0): the seventh review made ListBuilder cache its parent's entry array. A builder on a LIST that sits inside another LIST's child (LIST(LIST(T)), or a LIST field of a list's STRUCT elements), kept across the outer list's rows, then wrote through a dangling pointer after the outer list grew, because an outer reserve reallocates that vector's data buffer (LESSONS L18). The reviewer measured a segmentation fault on DuckDB 1.5.6 and 2.0.0 and a pass with only the set_entry line reverted. set_entry fetches the array on every row again, as 0.19.0 did; the child-writer cache is kept. append_metadata entry-point note: a Mach-O symbol table spells C symbols with a leading underscore, so the note fired on every correct macOS build and advised a rename that would break LOAD. The extension name is now DuckDB's (the file name up to its first '.', lowercased) and the quoted error is DuckDB's. LogicalType: the TIMESTAMPTZ_NS engine check moves from precheck, which MockRegistrar runs with no DuckDB behind it, into try_new, so the offline registrar no longer panics; a 1.x development build is judged by the release it names. VectorWriter::set_null returns early on a vector with no validity mask, as the C function it replaced did. Verified so far: lib and bin unit tests (867 and 49) pass with default features. The new live regression test (inline_paths::a_list_builder_on_an_inner_list_survives_the_outer_lists_reserves) was written and validated by the reviewer; I have not yet run it myself, and I have not yet shown that it fails with list_builder.rs reverted. That check, and the live suites on 1.5.6 and 2.0.0, are still to do. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP * Cap the DuckDB bindings range below 2.1 and ship an allow-list package libduckdb-sys / duckdb: ">=1.4.4, <2" becomes ">=1.4.4, <1.20100". libduckdb-sys numbers DuckDB vX.Y.Z as 1.(10000*X + 100*Y + Z).N, so the new bound admits every DuckDB 1.4.4 - 2.0.x binding and stops before DuckDB 2.1 (1.20100.0). The old range admitted bindings this crate cannot be compiled against: libduckdb-sys 1.20000.x keeps the root-level re-exports quack-rs (and the names its exported macros expand to) behind the default feature `capi-v1`, next to a "TODO: Remove in the future". The deps reviewer deleted only that re-export from a copy of 1.20000.1 and quack-rs then failed with 214 errors; a fresh `cargo add libduckdb-sys` already writes 1.20000.1. Published 0.18.0 and 0.19.0 cannot be narrowed; this only protects new releases. default-features = false for libduckdb-sys: from 1.20000.x the default features pull an HTTP/TLS/zip toolchain into every consumer's build (the reviewer measured 67 crates / 36 s CPU against 35 crates / 22 s when both quack-rs and the consumer turn them off). Up to 1.10506.x those build dependencies are not optional, so it changes nothing there. `loadable-extension` implies `capi-v1`. Package: `exclude` (which ships any new top-level file by default) becomes an `include` allow-list. `cargo package --list --locked` lists 247 files before and after, which I re-ran: the two examples under examples/*.rs ship, and the "ignoring example" warning on every package run goes away. cargo-machete ignore list for `cc` and `criterion`, both used outside the places it looks. Verified so far: `cargo package --list --locked` = 247 files and Cargo.lock unchanged. NOT yet verified by me: a build against the 1.4.4 floor and the 1.20000.1 bindings with the lean feature set (a local matrix is running; CI's dependency-floor, msrv and test-duckdb-2-0 jobs will also exercise it). Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP * ci: run the six upstream-comparison guards through scripts/upstream-guard.sh (CI-2) What was wrong: abi-table (two steps), platform-table, spdx-list, autoload-entries and msrv-vs-duckdb-ci each ran `python3 scripts/check-X.py || status=$?` and mapped exit 2 to "upstream unreachable; check skipped". Python itself exits 2 for "can't open file", so renaming or deleting a guard script left its job green; and on a release (release.yml calls ci.yml) an upstream outage skipped all six silently. Evidence (ci reviewer, re-run here): the old inline wrapper around a missing script printed the "skipped" warning and exited 0. Change: the ci reviewer's patch 01 (scripts/upstream-guard.sh: refuse a missing script; 0/1 pass through; 2 is a warning, or a failure when QUACK_STRICT_UPSTREAM=1, which ci.yml sets when github.ref_type is 'tag'). Added on top: `upstream-guard.sh --self-test` (9 cases on stub scripts: exit 0/1/2/3, strict and not, missing script), run by the `doc` job, so the mapping is itself under test. Ran: shellcheck 0.11.0 clean; self-test 9/9; five mutants of the wrapper (no exists-check, strict ignored, 2 -> fail, status not passed through, `|| true` on the python call) each turn the self-test red; the six real guards through the wrapper: abi-table, api-coverage, platform-table, spdx-list, msrv-vs-duckdb-ci exit 0, autoload-entries exit 0 with the "skipped" warning after a transient "Remote end closed connection" (the case exit 2 is for); a missing script exits 1 with ::error::. actionlint 1.7.12 clean on ci.yml (-ignore SC2129). Not run: the workflow on GitHub. * inline_paths: use lambda syntax DuckDB 2.0.0 accepts (identical to the coordinator's main-branch fix) DuckDB 2.0.0 rejects the arrow lambda `j -> [...]` by default (Binder Error: Deprecated lambda arrow), so a_list_builder_on_an_inner_list_survives_the_outer_lists_reserves could not run on 2.0.0. Same one-line text change the coordinator committed on the main branch (`lambda j: ...`, accepted by 1.4.4, 1.5.6 and 2.0.0), applied here so the cross-engine run of inline_paths (finding list item 8) can use it and the merge is clean. * ci: check-ci-aggregate.py no longer passes while a gate is removed (CI-7) What was wrong: four mutations of ci.yml that remove a gate kept the `ci-ok` aggregate check green (ci reviewer, mutation probes agg-6..agg-10): a job demoted with `continue-on-error: true` and dropped from `needs`, a step-level `continue-on-error` in a blocking job, the ci-ok body gutted with the checked pattern kept in a comment, and a new job declared with a YAML anchor or trailing comment (invisible to the parser). Nothing checked the README's gate table, which is documented as generated. Change: the ci reviewer's patch 02 (explicit INFORMATIONAL and INFORMATIONAL_STEPS sets; job ids with a trailing comment or anchor; comment-stripped safety patterns; the README table must list exactly ci.yml's jobs and kinds). One hole found reviewing it: step-level `continue-on-error` was checked only in `blocking` jobs, which excludes `ci-ok` itself, so `continue-on-error: true` on the aggregate's own step made "CI passed" green whatever its needs did. The step check now covers every non-informational job, ci-ok included. Regexes named, `l` renamed (ruff E741/E501), docstring lists every check. Ran (copy-based runner, $S/impl/infra/mut_aggregate.py; never edits the tree): baseline green (35 blocking jobs); 17 gate-removing probes RED (the reviewer's agg-1..13 plus agg-15 ci-ok step continue-on-error, agg-16 README row dropped, agg-17 README kind wrong, agg-18 job-level continue-on-error on ci-ok); false-positive probe agg-14 (`fuzz: # smoke`) GREEN. agg-15 against patch 02 as written: GREEN (the hole), with the fix: RED. ruff clean (default and E,F,W). * Use the new lambda syntax in the ListBuilder regression test's oracle CI run 701 (the previous commit) failed the blocking "Test against DuckDB v2.0.0" job: the new regression test for the ListBuilder entry-array fix compared its output with `list_transform(range(x % 7), j -> [...])`, and DuckDB 2.0.0 rejects the arrow lambda by default ("Binder Error: Deprecated lambda arrow (->) detected"). The code under test was not at fault: the other 394 live tests passed on 2.0.0. I had not run the test on 2.0.0 before committing it; the previous commit message said so. `lambda j: ...` is accepted by 1.4.4, 1.5.6 and 2.0.0 (checked by running the oracle expression in each CLI). No other arrow lambda occurs in the repository's tests, book, README or examples (grep). Verified: the four inline_paths tests pass live on DuckDB 1.5.6 (4 passed). NOT yet confirmed by me: the live run on 2.0.0 (queued behind another build on the shared lock); CI's "Test against DuckDB v2.0.0" job will be the check. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP * ci: a release commit with a stale lockfile now fails in minutes, not after the whole CI run (CI-1, CI-15) What was wrong: release.yml packages and publishes with `--locked`, but nothing before the `package` job checked that Cargo.lock names the version Cargo.toml was bumped to: `validate` checks only Cargo.toml and the CHANGELOG heading, and ci.yml's publish-dry-run ran `cargo publish --dry-run --allow-dirty`, which quietly rewrote the lock. A release commit made by RELEASING.md's steps (which said not to touch Cargo.lock) passed validate and all of ci.yml and failed `cargo package --locked` afterwards (ci reviewer, VALIDATED on a scratch bump). Other release metadata (CHANGELOG links, CITATION.cff, SECURITY.md row, README "latest" line, `quack-rs = "0.X"` snippets) was checked by nothing. Change: the ci reviewer's patch 03, minus its RELEASING.md part (merged by hand with the docs and harden reviewers' text in a later commit): scripts/check-release-metadata.py, run by the `doc` job and by release.yml `validate`; publish-dry-run is `cargo publish --dry-run --locked`. Extended: the check covers every committed lockfile that records quack-rs (root, examples/hello-ext, fuzz, book/doctest; benches/engine once it is committed), not only the root one. `validate`'s lightweight-tag error no longer claims the job checks signatures (CI-15). Ran: the check on this tree: agrees (0.19.0). On a copy with only Cargo.toml bumped to 0.20.0: exit 1, 25 places, including all four lockfiles. After `cargo update --workspace --offline` in three of the four lockfile dirs: exit 1 naming only fuzz/Cargo.lock; each updated lockfile differs from the original by exactly the quack-rs version line. ruff clean; actionlint clean; check-ci-aggregate and check-workflow-expressions green. * release: compare the .crate with the attested hash before uploading it; reset draft/prerelease on edit (CI-6, HARDEN-11, CI-9) What was wrong: (CI-6 = HARDEN-11) `publish` re-packaged after the manual approval, uploaded, and only then compared crates.io's .crate with the SHA256SUMS the `package` job attested: a mismatch could only be reported once the version was live and irreplaceable. (CI-9) When a GitHub release already existed, `gh release edit` never cleared `--draft` and only ever added `--prerelease`, so a draft stayed invisible and a wrong prerelease flag stayed. Change: the ci reviewer's patch 04, taken as the single implementation of the pre-upload check (the harden reviewer's patch 09 does the same but downloads the artifact into the checkout, where `cargo package` counts it as an uncommitted change and would include it; declined). `package` records `rustc --version`; `publish` installs that rustc, downloads the attested artifacts to $RUNNER_TEMP, runs `cargo package --no-verify --locked` before any credential step and stops unless the sha256 equals SHA256SUMS; the post-publish crates.io check reads the same file. `gh release edit --draft=false` and `--prerelease` / `--prerelease=false` both ways; upload-artifact `overwrite: true` for a whole-workflow re-run. Added: the step also refuses when this job's `rustc` is not the recorded one. dtolnay's action only sets rustup's default, which rust-toolchain.toml overrides, so the `toolchain:` input alone did not guarantee it; the comment said it did. Ran: the step's run block, extracted from this release.yml with PyYAML, in a clone of the v0.19.0 release commit (9c2dc76, = refs/tags/v0.19.0^{} by git ls-remote) with RUSTUP_TOOLCHAIN=1.99.1: crates.io's own hash (1d806ed0..., sha256 of the downloaded quack-rs-0.19.0.crate) -> exit 0, packaged hash identical; tampered SHA256SUMS -> exit 1; recorded rustc 1.98.0 -> exit 1; empty recorded rustc -> exit 1; SHA256SUMS naming another file -> exit 1. actionlint clean, check-workflow-expressions green. `gh release edit --help` (gh 2.89.0) documents `--draft=false`. Not run: the job on GitHub, the environment approval, Trusted Publishing. * ChunkWriter: count claimed rows honestly and add release_row (UNSOUND-1) What was wrong: ChunkWriter::next_row claims a row (returns its index and counts it) and the drop publishes every row counted, but the docs called the count "rows written". The natural loop over a source of unknown length, `while let Some(row) = cw.next_row() { let Some(v) = src.next() else { break }; ... }`, claims one row it never writes, and that row is published holding whatever DuckDB's reused output chunk last held. Reviewer `unsound` validated a wrong answer on 1.5.6 (stale 7 from the previous scan call); for a LIST/MAP column written by hand the stale {offset, length} entry is a conjectured out-of-bounds read. What changed: - `ChunkWriter::release_row(row)` gives back the most recently claimed row, so the drop does not publish it; the next `next_row` returns the same index. The row is named, not implied, so giving back the wrong one is loud: any row but the last claimed one panics with a message naming the row that could be given back (`# Panics`; the callback macros turn it into a SQL error). - Module, struct, `next_row`, `row_count` and `DataChunk::into_chunk_writer` docs now say "claimed", spell out the hazard, and show the source-runs-out loop with `release_row`. The drop cannot know whether the last claimed row was written (writes go through VectorWriters that do not report back), so it asserts nothing; the struct docs say so. Tests: - unit: release_row_gives_back_the_last_claimed_row, release_row_refuses_any_row_but_the_last_claimed_one. - live: chunk_writer::a_claimed_row_the_source_cannot_fill_is_given_back_not_published_stale reproduces the reviewer's probe (scan 0 fills a chunk with 7, scan 1 claims three rows from a two-item source). 1.5.6: passes. Against 734bb15's src/chunk_writer.rs (no release_row; the test's release line replaced by `let _ = row;`, the only thing 734bb15 allows) it fails: `[1, 2, 7] left: 2051 right: 2050`. The test also pins the hazard the docs describe (no release: tail [1, 2, 7]). * ci: lint every workflow with actionlint, checksum-pinned (CI-11) What was wrong: no workflow linter ran in CI. The workflows README said actionlint "cannot be checksum-pinned the way osv-scanner is"; the release publishes actionlint_<version>_checksums.txt. check-workflow-expressions.py covers only empty/unclosed expressions: `${{ x == }}` passed it. Change: the ci reviewer's patch 05: a blocking `workflow-lint` job (actionlint 1.7.12 from the release tarball, sha256-verified; fails if shellcheck is missing, because actionlint then skips every run: block silently; SC2129 ignored as style), in ci-ok's needs, the README gate table and the ci.yml header; README paragraph corrected. Ran: `git ls-remote --tags rhysd/actionlint`: v1.7.12 is the newest tag. The release's actionlint_1.7.12_checksums.txt linux_amd64 line, the pin in ci.yml and the downloaded tarball's sha256 are all 8aca8db9...a3d8; the install step, extracted from ci.yml, run verbatim: `actionlint.tar.gz: OK`, version 1.7.12. actionlint as the job runs it, over all six workflows: clean. On a copy with `echo ${{ needs.nonexistent.outputs.version == }}`: check-workflow-expressions exit 0, actionlint exit 1 ("unexpected end of input ... [expression]"). The shellcheck guard with shellcheck off PATH: exit 1 with ::error::. check-ci-aggregate: 36 blocking jobs. READ, not run: the ubuntu-24.04 runner image lists shellcheck 0.9.0-1 (actions/runner-images Ubuntu2404-Readme.md, image 20261026.354.1); I ran 0.11.0 locally, so the runner may report a slightly different set. * ci: cache examples/hello-ext's own target dir in the three jobs that build it (CI-13) What was wrong: examples/hello-ext is its own Cargo workspace (no [workspace] in the root manifest), and Swatinem/rust-cache caches only the root workspace's target/ unless told otherwise, so example-check (x3), symbol-check (x2) and extension-load (x6) rebuilt hello-ext's dependency tree and quack-rs with fat LTO on every run (ci reviewer; 81 s cold locally under load). Change: the ci reviewer's patch 06: `workspaces: ". -> target" and "examples/hello-ext -> target"` on those three jobs' rust-cache step. Ran: actionlint clean. READ: rust-cache's src/config.ts at the v2.9.3 pin (d1527c8) splits the input on newlines and resolves `$root -> $target` as path.join(root, target), i.e. examples/hello-ext/target. CONJECTURED, not measured: the time saved (cache hit rates cannot be read from here). The fuzz/ and book/doctest/ targets stay uncached. * ci: scaffold-compile cannot pass by running zero tests (CI-8) What was wrong: `cargo test scaffold_generated_code_compiles -- --nocapture` compiles every test target and runs the filter in each; `cargo test <filter>` exits 0 when nothing matches, so renaming the test would have left the job green with nothing run (ci reviewer: `...compilez` -> `running 0 tests ... 71 filtered out`, exit 0). Change: the ci reviewer's patch 07 (`--test integration_test ... --exact`, output tee'd), with the check tightened: the libtest summary line must read `test result: ok. 1 passed;` rather than grepping for the `test ... ok` line, which a test that printed under --nocapture would split. Comment corrected (the old form ran the one test, in one of nine binaries). Ran: the new grep against libtest output: the reviewer's --exact run log (`1 passed`) exit 0, the zero-test log (`0 passed ... 71 filtered out`) exit 1. The test is top-level in tests/integration_test.rs and captures its child cargo's output (`.output()`), so --exact matches it and it prints nothing on success (read). actionlint clean. Not yet run by me: the cargo test command itself (disk below the 4 GB floor at the time; see the impl report). * docs: README front page, libduckdb-sys range, 0.20 snippets, DuckDB 2.0 behaviour fixes, tutorial on guarded callbacks What was wrong (eighth review, docs/deps/author reviewers; each re-verified before writing): - README clipped code at ~64 columns on crates.io, had no maintenance / help / link row, and several ambiguous sentences (DOCS-9). Adopted patch 03 line by line; cut nothing the patch added except the "audited" seal in the tagline (the Status section says audits keep finding defects). - README claimed "no C, no C++, no glue code" (DEPS-11). True: the repository holds Rust only. Not true: `cargo tree` shows `ring` (C) in the default libduckdb-sys graphs; the bundled-test features compile C/C++; the community flow needs Python and git. README and Installation now say so. - libduckdb-sys range `>=1.4.4, <2` admits bindings that would not compile (DEPS-2). Every snippet and sentence now shows `>=1.4.4, <1.20100`, with default-features = false, and Installation explains the upper bound, what to do when 1.20100 appears, and `cargo tree` counts measured here (1.20000.1: 65 crates default vs 30; 1.10506.0: 74 vs 72). All `quack-rs = "0.19"` snippets are "0.20". - DuckDB 2.0.0 contradicts three documented behaviours (DOCS-3), measured on 1.4.4/1.5.6/2.0.0: interval '1 month'-'1 day' vs '29 days' (eq/gt flip), bare-identifier table macro argument warns, VerifyNullHandling is compiled into release builds in 2.0.0 and runs only after SET debug_verification_mode='VERIFY_FUNCTIONS' (INTERNAL Error observed). - arg_max 3-argument signature is (ANY, ANY, BIGINT) on all three engines. - publishing.md printed `...yml@v2.0-cyanoptera`, which Cloudflare rewrites to "[email protected]" on the live site (DOCS-6); reworded without the @. Also: the v1.5.6 branch of extension-ci-tools is not the commit of v1.5-variegata. - "Your First Extension" taught unguarded raw callbacks and an aggregate that segfaults under OVER () with no warning (DOCS-4). Rewritten on aggregate_*_callback! and map1_str, with a warning callout listing the shapes that crash. Built from the page's visible code and run on 1.4.4, 1.5.6 and 2.0.0: output byte-identical to the page. Window shapes re-run on the three engines (5000 and 300000 rows, one process per shape): OVER (), explicit ROWS/RANGE UNBOUNDED..UNBOUNDED frames (also with PARTITION BY) and agg(x ORDER BY y) segfault on 1.4.4 and 1.5.6; OVER (PARTITION BY p) without ORDER BY segfaults on 1.4.4 only; all pass on 2.0.0. Ran: book doctest first_extension filter, 13 passed (live 1.5.6). * arrow import: refuse offsets, lengths and indices DuckDB reads out of bounds (FFI-1) What was wrong: data_chunk_from_arrow's layout walk read a list's first and last offset and used (first, last - first) unchecked. A negative first offset, a last offset past the child, or offsets that decrease (also in the middle, where both ends look fine) were accepted; DuckDB imports the child zero-copy and reads it out of bounds once the chunk is read (reviewer `ffi`: SIGSEGV on 1.5.6 and 2.0.0, valgrind invalid read). `last - first` was unchecked i64 arithmetic ([i64::MIN, 0] panics under overflow checks). Checked the same class elsewhere (DuckDB arrow_conversion.cpp read at v1.5.6 and v2.0.0): - LARGE_LIST (+L) and MAP (+m) share the list path: same defect. At 734bb15 a +L [-6,-2] was refused only by a DuckDB INTERNAL cast error, and a map past its child was "refused" by DuckDB's map verification after it had already read 9 keys from a 4-element buffer. - LIST_VIEW: negative offsets/sizes passed (DuckDB reads them unsigned). - FIXED_SIZE_LIST, struct fields, union members: a child shorter than the rows its parent reads was never compared with its length (top-level columns only). - dictionary indices: DuckDB builds the selection from them unchecked (SetSelectionVectorLoop), so an index past the dictionary is read past it; quack-rs's own flatten then copies through it. What changed (new src/arrow/import_layout/bounds.rs): - list_range reads every offset of the rows DuckDB reads and refuses a negative one, a decrease, or an end past the child, with checked arithmetic; used for +l, +L and +m. - list_view_entry refuses a negative list-view offset or size. - covers refuses any node shorter than inherited + size rows (struct field, list/fixed-size-list child, union member). - dictionary_indices refuses an index outside 0..dictionary length in every row DuckDB uses (rows NULL in the indices' own bitmap with null_count > 0 are skipped, as DuckDB masks them); Shape records the index type from the schema format. A row NULL only in an enclosing struct must still hold a valid index, as the Arrow spec requires of every non-NULL index. - data_chunk_from_arrow's # Errors lists the new refusals. Tests: - unit (src/arrow/import_layout/tests.rs): list_offsets_outside_the_child_are_refused, negative_list_view_offsets_or_sizes_are_refused, a_child_shorter_than_its_parent_reads_is_refused, dictionary_indices_outside_the_dictionary_are_refused, index_formats_map_to_their_integer_types; every pre-existing layout test still passes (52/52). Mutation: reverting the list hunk to 734bb15's two reads, removing covers, list_view_entry or the index check each fails its test. - live: arrow_layout::list_offsets_and_indices_outside_their_child_are_refused_before_duckdb_reads_them (hand-built +l/+L/+m/+w:3/dictionary arrays, each beside a valid neighbour that must import with the right values). 1.5.6: 44/44 arrow live tests pass. With 734bb15's src/arrow/import_layout.rs: the test binary dies with SIGSEGV (signal 11); a non-reading probe of the same cases shows 734bb15 accepted the +l -5, past-child and decreasing offsets, the short fixed-size-list child and the out-of-range index. * ci: pin the Rust toolchain to 1.99.1; an informational job tracks the latest stable (CI-3) What was wrong: rust-toolchain.toml said `channel = "stable"` and 31 jobs installed `toolchain: stable`, with RUSTFLAGS `-D warnings` and clippy's pedantic/nursery groups enabled: any Rust release (every six weeks; 1.100 is due about 2026-11-12) could turn every job red with no change here, as 1.99.0's `assert_is_empty` already did once (AUDIT.md 12.7). Change (the ci reviewer's patch 09, adopted by the maintainer's decision, with changes): - rust-toolchain.toml `channel = "1.99.1"`; every `toolchain: stable` in ci/release/docs/mutants/coverage/benchmarks.yml -> `1.99.1` (32 pins), test-bundled-duckdb-2-0 included (it is informational for build time, not to track Rust). MSRV (1.86.0), nightly and beta jobs unchanged. - New informational `latest-stable` job: `toolchain: stable`, RUSTUP_TOOLCHAIN=stable over the toolchain file (so rust-cache's key uses it too), fmt --check, clippy -D warnings (default and duckdb-1-5-4), rustdoc, lib tests, all `cargo +stable`. continue-on-error, outside ci-ok, in check-ci-aggregate.py's INFORMATIONAL set and the README table ("the four marked informational"). - `security` now installs the pinned toolchain explicitly: it had none and relied on rustup installing what rust-toolchain.toml names on demand (on by default since rustup 1.28.1, but an image can turn it off). - scripts/check-toolchain-pin.py rewritten job-aware: patch 09's version read only `toolchain:` inputs, rejected `stable` everywhere (so a latest- stable job could not exist) and passed expressions and `cargo +X` / `RUSTUP_TOOLCHAIN` unseen. Now every reference is checked: pin, MSRV, nightly (dated allowed), stable/beta only in informational jobs, run-time values only in the two listed (release.yml publish, ci.yml scaffold-e2e). Run in the `doc` job. - ci.yml header and three comments that said the file pins "stable"; release.yml package comment. Verified: `rustc +1.99.1 -vV` = 1.99.1 (58cf8f9c3 2026-10-13); the rust dist channel-rust-stable.toml (date 2026-10-15) and channel-rust-1.99.1.toml name the same commit; dtolnay/rust-toolchain's action.yml (READ at 683b588 and e2a55d2, identical) passes `1.99.1` verbatim to `rustup toolchain install` and runs `rustup default`, which a toolchain file overrides (hence `cargo +stable` / RUSTUP_TOOLCHAIN in the new job); the ubuntu-24.04 image (runner-images readme, 20261026.354.1) ships Rust 1.99.1 and rustup 1.29.2. Mutation probes ($S/impl/infra/mut_toolchain.py): 12 RED as expected (stable in a blocking job via input / `cargo +` / RUSTUP_TOOLCHAIN env / `rustup run` / workflow env; toolchain file back to stable, not exact, bumped alone; an older pin; an unlisted `$var`; latest-stable losing continue-on-error; release.yml package on stable), 2 GREEN as expected (dated nightly; a comment). actionlint clean; check-ci-aggregate 36 blocking; zizmor 50 -> 52 findings, the two new dtolnay uses (pedantic superfluous-actions), default-visible unchanged. Not run: any job on GitHub; the latest-stable job's commands on 1.100 (the ci reviewer ran clippy on 1.100.0-beta.7 clean). * ci: fold in Dependabot #145 by hand; check the scaffold's action pins against the workflows (DEPS-15) What was wrong: Dependabot #145 bumps three actions. Merged as is, it would (1) leave all 39 dtolnay/rust-toolchain lines commented `# master 2026-10-08` on a 2026-10-15 commit, and the ci.yml header naming the old commit; (2) leave the scaffold's own copies of the pins (src/scaffold/templates_ci.rs) on the old commits: nothing compared them with .github/workflows, so generated extension CIs would silently keep older actions (deps reviewer, DEPS-15). Change, every workflow: - Swatinem/rust-cache v2.9.2 -> v2.9.3 = d1527c8f67ef9af357290475d4af4b0fab8f12e0 (35 uses) - rust-lang/crates-io-auth-action v1.0.5 -> v1.0.6 = 3268eb413133e2960fa4ae0e963ca76380c54cd9 - dtolnay/rust-toolchain -> 683b588c487a69d01f6c6ddf40f036ff682cc2c8 (master HEAD, 2026-10-15), commented `# master` (41 uses): the branch has no tags and Dependabot moves the commit, so a date in the comment goes stale. - ci.yml header reworded so it stays true across those bumps. - scripts/check-action-pins.py, in the `doc` job: every remote `uses:` is a 40-hex commit; each action repository is pinned one way across all workflows (commit and the comment's first word); each pin in templates_ci.rs that names an action the workflows use must match; no pins found on either side is an error. - dependabot.yml: hello-ext gets no duckdb/libduckdb-sys ignore, on purpose, and says why: the example tracks the newest bindings (2.0's), unlike the MSRV-held root lock, and is where CI builds and loads them. Verified: `git ls-remote`: rust-cache refs/tags/v2.9.3^{} = d1527c8, crates-io-auth-action refs/tags/v1.0.6 = 3268eb4, dtolnay HEAD and master = 683b588. Upstream diffs read (shallow fetches): rust-cache 2.9.2..2.9.3 action.yml unchanged, src/ has three fixes (await, `return`->`continue` in timestamp pruning, a warning -> info), dist/ rebuilt (not rebuilt by me); crates-io-auth-action 1.0.5..1.0.6 action.yml unchanged, dependency/CI updates and dist/ rebuild; dtolnay e2a55d2..683b588 is one line in scripts/update-revs.sh (e2a55d2 is an ancestor). check-action-pins.py: on this branch alone exit 1, naming exactly the two stale scaffold pins (RUST_TOOLCHAIN, RUST_CACHE) with the strings to use; on a copy with them updated: exit 0, 139 uses, 12 repositories; probes (copy-based, $S/impl/infra/mut_pins.py): one use on another commit, a stale version comment, a floating tag, a scaffold pin differing, templates_ci.rs pins no longer parsing, release.yml on a tag -> all RED; a date after `master` and cache/restore+save -> GREEN. dependabot.yml validates against SchemaStore's dependabot-2.0 schema (jsonschema 4.26.0; 4 blocks, cooldown on all 4); a copy with a bad cooldown and an unknown key is rejected. actionlint clean; zizmor unchanged (52, default-visible 2). * Cap type-nesting walks and clamp the cardinality hint (HARDEN-6, HARDEN-7) Adopted from reviewer `harden`'s patch 04, line by line (all of it is in src/scalar/**, src/table/** and tests/**; nothing in src/query or src/value). HARDEN-6: collision::type_string, signature::describe and type_check::contains_type recursed on a logical type with no bound; a LIST of LIST ... a few thousand deep (as a reader of an untrusted schema builds) overflowed the stack and aborted the process. MAX_TYPE_NESTING (256) bounds all three: type_string returns None (not rendered, not checked), describe writes "...", contains_type counts it as a match (every caller uses the answer to refuse something). HARDEN-7: BindInfo::set_cardinality(u64::MAX, _) made any join with the function fail with "INTERNAL Error: Information loss on integer cast" on 1.5.6. The hint is clamped to i64::MAX, documented. Changed from the patch: - hostile_input::a_deeply_nested_type_is_refused_not_recursed_into also registers a two-overload scalar set 3,500 levels deep, so describe's cap is tested: the patch's 2,000 levels do not overflow describe's smaller frame. At 3,500, with 734bb15's signature.rs alone, the test aborts with a stack overflow whose gdb backtrace is quack_rs::scalar::builder::signature::describe frames; with the cap it passes. At 6,000 levels DuckDB's own LogicalType::ToString overflows the same 2 MiB thread (gdb: ToString frames, during a later catalog scan), so MAX_TYPE_NESTING's docs now say the cap protects quack-rs's walks only. Evidence (1.5.6, live): hostile_input 5/5 pass. With 734bb15's collision.rs, signature.rs, type_check.rs and info.rs: a_deeply... dies with SIGABRT ("thread has overflowed its stack"), an_enormous_cardinality... fails with "INTERNAL Error: Information loss on integer cast: value 18446744073709551615 ...". * repo: typos, taplo and editorconfig configs; cargo-deny config for the CI-only graphs; hello-ext publish = false (DEPS-4, DEPS-5, DEPS-6) What was wrong (deps reviewer): no typos config (every finding a false positive), no taplo config, no .editorconfig; deny.toml cannot be applied to the hello-ext, fuzz and book/doctest graphs (unused-allowed-license is "deny"; libfuzzer-sys is "(MIT OR Apache-2.0) AND NCSA"; the doctest and bench crates have no license), so those graphs had no license/ban/source gate at all; deny.toml listed `sparse+https://index.crates.io/`, a form Cargo.lock never records (an `unmatched-source` warning every run); unmaintained/unsound defaulted to direct dependencies only; wildcards only warned; examples/hello-ext lacked `publish = false` (fuzz, doctest and benches have it). Change: the deps reviewer's patch 0001, files I own only: typos.toml, .taplo.toml, .editorconfig, deny.ci-crates.toml, the deny.toml changes (unmaintained/unsound "all", wildcards "deny" with allow-wildcard-paths, the one registry form), hello-ext `publish = false`. Not taken: the root Cargo.toml hunks (the `include` allow-list and [package.metadata.cargo-machete]) and book/doctest/Cargo.toml's machete metadata: the coordinator owns those files; the hunks are handed over in the impl report, and the `hygiene` job's machete step needs them. The justfile: declined, a third hand-kept copy of the gate commands (CONTRIBUTING.md and ci.yml are the others) with nothing checking it, the drift this repository already had with the README gate table and RELEASING's job list. docs patch 02's `_typos.toml` is the same idea; this `typos.toml` uses narrower regex ignores, and only one of the two should exist (typos reads one). Ran: typos 1.46.0 exit 0 on this tree; a planted `recieve` exit 2; with typos.toml removed 64 findings. taplo 0.10.0 fmt --check and lint exit 0 over 14 TOML files; a misformatted Cargo.toml line exit 1. cargo-deny 0.20.2: root `check` advisories/bans/licenses/sources ok, no unmatched-source warning (8 duplicate-version warnings remain); hello-ext, fuzz, book/doctest with --config deny.ci-crates.toml: all four ok; the same three with the old deny.toml: licenses FAILED (exit 4). cargo-machete 0.9.2 --with-metadata: flags cc, criterion (root) and the doctest crate's libduckdb-sys/proptest/quack-rs (false positives: build.rs, a [[bench]], generated doctests); on a copy with 0001's two manifest hunks applied: clean, and typos/taplo stay clean. * ci: a `hygiene` job (typos, taplo, cargo-machete) and cargo-deny over the CI-only graphs (DEPS-4, DEPS-6) What was wrong: CI ran cargo-deny on the root graph only; hello-ext, fuzz and book/doctest were read by the OSV job and nothing else, and benches/engine (lockfile gitignored) by neither. No spelling, TOML-format or unused-dependency check ran. Change: the deps reviewer's patch 0003, by hand on this branch's ci.yml: - `security` runs `cargo deny --config deny.ci-crates.toml check` on hello-ext, fuzz, book/doctest, and on benches/engine once its lockfile exists (grouped per crate). - `osv-scan` builds its --lockfile list in bash and adds benches/engine/Cargo.lock when present (the coordinator commits it), under `set -euo pipefail`. - New blocking `hygiene` job: typos 1.46.0, taplo 0.10.0, cargo-machete 0.9.2 as release binaries pinned by SHA-256 (curl --retry 5), then `typos`, `taplo fmt --check`, `taplo lint`, `cargo machete --with-metadata`; in ci-ok's needs, the README table and the header. On the pinned toolchain. Pins re-verified: `git ls-remote` shows tags typos v1.46.0 (newest is v1.51.1; kept, the config was validated against 1.46.0), taplo 0.10.0 (= release-taplo-cli-0.10.0), cargo-machete v0.9.2 (newest). cargo-machete publishes a .sha256 per asset: 48200087... = the pin = the downloaded asset. typos and taplo publish no checksum file (probed four names each: 404), so their pins equal the assets GitHub serves today, as the job's comment says (trust on first use). Ran (steps extracted from this ci.yml with PyYAML, executed verbatim on a copy): hygiene install: three `OK` lines, versions 1.46.0 / 0.10.0 / 0.9.2; typos, taplo fmt --check, taplo lint exit 0; cargo machete exit 1 on this branch alone (the cc/criterion and doctest false positives) and 0 with deps 0001's two [package.metadata.cargo-machete] hunks applied: those are in Cargo.toml and book/doctest/Cargo.toml, which the coordinator owns (handed over in the impl report). osv-scan install `osv-scanner: OK`; scan of the 4 lockfiles "No issues found"; with a benches/engine/Cargo.lock generated by cargo 1.99.1 (libduckdb-sys 1.20000.1) 5 lockfiles, "No issues found". CI-crates deny step: 3 graphs ok; with the bench lockfile 4 graphs ok. actionlint clean; check-ci-aggregate 37 blocking jobs. * repo: clippy.toml says its three thresholds are clippy's defaults (DEPS-6) What was wrong: clippy.toml set too-many-lines-threshold = 100 with the comment "Set to 100 to accommodate FFI registration methods", but 100, 7 and 25 are exactly clippy's defaults, so the file changed nothing and the comment implied a relaxation that does not exist (deps reviewer). Change: comments only. The values stay, written down so a future clippy changing a default does not silently change the bar; the file says so. Verified: clippy_config/src/conf.rs at tag rust-1.99.0 (raw.githubusercontent): cognitive_complexity_threshold = 25, too_many_arguments_threshold = 7, too_many_lines_threshold = 100. taplo fmt --check and typos clean. * Overload guard: compare types the way DuckDB resolves overloads (AUTHT2-1) What was wrong: the duplicate-overload guard (signature.rs, used by the scalar and aggregate set builders) and the catalog collision check (collision.rs, single and set registrations) compared parameter types structurally, so DECIMAL(4,1)/DECIMAL(18,3), MAP(VARCHAR,BIGINT)/ MAP(BIGINT,VARCHAR) and two ENUMs counted as distinct overloads, also nested in LIST/ARRAY/STRUCT. DuckDB's CastRules::ImplicitCast (read at v1.4.4, v1.5.6, v2.0.0) compares those by type id alone (cost 0 either way), so it registers the set and fails every call with "Could not choose a best candidate function" (reviewer `author-types`, VALIDATED on all engines). It also matches named STRUCT fields by name, in any order and case. What changed: - signature.rs: a Render mode. Render::Overload renders DECIMAL/MAP/ENUM by type id, lower-cases and sorts named STRUCT fields and UNION members (positional when a name is empty), recursing through LIST/ARRAY/STRUCT/ UNION; the guard compares those keys and reports the exact renderings, adding OVERLOAD_RULE (why they collide) when the exact types differ. - collision.rs: the catalog check compares overload_key(rendered), which reduces DECIMAL(w,s) and MAP(k, v) to DECIMAL / MAP at any depth, so round(DECIMAL(18,3)) beside the built-in round(DECIMAL) is refused. - Set/single builder docs state the rule. Documented as not detected (read from the source, not run): LIST(T) beside ARRAY(T, n), and a UNION whose members are a subset of another's (both asymmetric zero-cost casts). Tests: - unit: overload_keys_ignore_decimal_and_map_parameters, check_refuses_signatures_duckdb_resolves_by_type_id_alone, members_sort_by_name_only_for_the_overload_key_of_a_named_type. - live (tests/ffi_roundtrip/overload_keys.rs, 4 tests): eight refused scalar pairs (DECIMAL, MAP, ENUM, LIST(DECIMAL), ARRAY(DECIMAL,2), STRUCT(DECIMAL), LIST(MAP), STRUCT field order/case), an aggregate DECIMAL pair, the catalog round(DECIMAL(18,3)) and a MAP re-registration; five distinct pairs (INT/ BIGINT, LIST(INT)/LIST(VARCHAR), BIGINT[3]/BIGINT[4], STRUCT(a)/STRUCT(b), DECIMAL/BIGINT) register and each call reaches its own overload. 1.5.6: 4/4 pass. With 734bb15's signature.rs and collision.rs, 3 fail: every set and round(DECIMAL(18,3)) registers and the call then fails "Binder Error: Could not choose a best candidate function ..."; a probe of all eight scalar pairs at 734bb15 showed each one ambiguous on 1.5.6. * scripts: check-api-coverage.py counts only library code as wrapping a slot (APIGAPS-4, CI-14) What was wrong: a slot counted as "wrapped" when its name appeared in the code of any file under src/, after stripping comments only. So duckdb_open and duckdb_close, used only by #[cfg(test)] code (src/query/live_tests.rs, client_context.rs tests), were in the 447, and a name kept in a string literal satisfied the check after its wrapper was deleted (ci reviewer probe cov-4 stayed green). AUDIT 5.1's own method gave 445 (apigaps reviewer, VALIDATED with an independent scanner). Change: - a small lexer strips comments (nested block comments too) and every literal (strings, raw/byte/C strings, chars; lifetimes stay code); - items under a cfg that requires `test` (`test`, `all(.., test, ..)`; not `any(test, x)` or `not(test)`) are cut by brace/semicolon extent, and files loaded only through such a `mod x;` (with `#[path]`), plus their child modules, are skipped; src/bin/ is not library code; - a new allowlist class `internal`: library code calls the slot but no public API exposes it (the apigaps reviewer found two: duckdb_create_bit, duckdb_result_error_type). Such a slot is not counted as wrapped, and is flagged if it stops being used. The allowlist file itself is agent `api`'s and is not edited here; - the summary reports wrapped, internal-only and unused counts, and the names only tests/strings/comments mention; `--self-test` (23 expectations on fixed snippets) runs in the abi-table job. Effect on this branch alone: 546 slots (v1.5.6 header), 445 used by library code, and the check fails with duckdb_open and duckdb_close unclassified until the allowlist lists them (host-side: opening a database is a host's job). That entry, and any `internal` ones, are agent `api`'s. Ran: on both engine headers, the used set equals the apigaps reviewer's derive.py (lib + testing) name by name: 445 and 445, no difference. Probes on copies (FIX = open/close listed host-side), $S/impl/infra/mut_cov.py: baseline green; RED for an allowlist line deleted, a wrapped slot listed, the only wrapper removed, the name kept in a string (cov-4), in a raw string, in a doc comment, the only call moved under #[cfg(test)] and under cfg(all(feature, test)), an unused slot listed internal; GREEN for a used slot listed internal (wrapped 445 -> 444) and a call under cfg(any(test, feature)); the same on the v2.0.0 header. Scanner mutants (raw strings kept, line comments kept, all() / any() predicate logic broken, test-module files not skipped, src/bin counted): each fails the self-test. ruff clean. * Let closure-built scalars be overloads of a set: overload_typed (AUTHT2-2) What was wrong: map1/map2/try_map1/... return a TypedScalarFunctionBuilder, which a ScalarFunctionSetBuilder could not take, so a closure-built function could not be overloaded on DuckDB 1.4.x (a supported engine), where a second registration under a taken name is refused - with a message telling the user to use ScalarFunctionSetBuilder, which could not take it (reviewer `author-types`, VALIDATED on 1.4.4). Decision: the smallest clean path is an entry on the set builder, not a conversion into ScalarOverloadBuilder: a ScalarOverloadBuilder is mutable (`returns`, `param`, `function`, `extra_info`), which would reopen the signature desync TypedScalarFunctionBuilder exists to prevent. What changed: - `ScalarFunctionSetBuilder::overload_typed(TypedScalarFunctionBuilder)` moves the closure's fixed signature, trampoline, extra_info, null handling and stability into one overload spec; nothing can edit them. The overload takes the set's name; one built under another name (case-insensitive) is refused by `register`/`check_parts` naming the overload, instead of registering under a name its builder did not say. - The pre-1.5.0 "cannot add an overload" message names `overload_typed` next to `overload`; typed.rs module docs point at it. Tests: - unit: a_closure_built_overload_keeps_its_signature_and_takes_the_sets_name; an_engine_that_cannot_overload_refuses_every_existing_name now also checks the message names `overload_typed`. - live: overload_keys::closure_built_functions_overload_one_name_through_a_set (i32/i64/f64 closures under one name; each call returns its own type; the one-by-one path is an overload from v1.5.0 and refused with the new message before it). 1.5.6: passes. At 734bb15 it cannot compile: there is no overload_typed, which is the defect. * scripts: two upstream guards no longer pass on a reshaped upstream (CI-14) What was wrong (ci reviewer's mutation run, CI-14): - check-msrv-vs-duckdb-ci.py read only the first word of a SHA pin's comment, so `# v1.86.0` and `# rust 1.86.0` parsed as "v1.86.0" / "rust", i.e. floating, not a constraint; it also never read a `toolchain:` input, which is the only place a pin of the action's `master` branch (the style quack-rs's own workflows use) names its Rust. An upstream switch to any of those styles would have silenced the guard. - check-autoload-entries.py had no floor: if upstream's entry shape changed, the pattern matched nothing and the union of nothing printed "OK: src/catalog.rs covers ..." with exit 0. Change: the MSRV guard takes the first version number anywhere in the comment (`v` stripped; `master 2026-10-08` still reads as floating), also reads `toolchain:` inputs, and its self-test covers each style plus parse(); exit codes unchanged. The autoload guard refuses (exit 2, "could not parse", which fails a release run) when an array's parsed entries differ from the number of `{` entries in it, or it has none; it retries a fetch up to three times, since it makes two per release and a release run now fails on exit 2. Ran: real runs against upstream: msrv-vs-duckdb-ci OK (v2.0-cyanoptera 1.97.1; v1.5-variegata and v1.4-andium 1.86.0 + stable; main) and FAIL with exit 1 on a copy with rust-version 1.88.0; autoload OK for 8 releases v1.5.0..v2.0.0 (EXTENSION_TYPES 2, EXTENSION_COLLATIONS 130 at v2.0.0). Parser mutants of the MSRV guard (first-word-only comments, toolchain: inputs ignored, `v` not stripped): each fails its self-test. autoload's upstream_names() on doctored copies of the real v2.0.0 header: a third field in every entry, one reshaped entry, an emptied EXTENSION_TYPES -> ValueError each; the previous code parsed 0, 129 and 0 names without complaint. ruff clean. Not changed: check-platform-table's accept-list (by design) and check-hello-ext's two checks that cannot fail (the fixture is examples/hello-ext/sql_checks.txt, not mine; the script already says so). * docs: correct the author-review findings (bind cannot set a return type, DECIMAL, alias types, ErrorData, COPY, table functions, Arrow, SET threads) and warn that std::fs bypasses DuckDB's permission settings Each fix was re-run on DuckDB 1.4.4 / 1.5.6 / 2.0.0 (probe extensions built from this tree; counts below are from those runs): - scalar.md: the bind callback cannot set the return type (v1 C API has only bind_get_argument/_count/_extra_info/_set_error; grepped from the 2.0.0 header). The raw examples are now scalar_callback! with checked arithmetic and report overflow through set_error (double_it(9223372036854775807) is a tested error); the closure example no longer teaches `x * 2`. - scalar.md: a DECIMAL parameter is not generic. A DECIMAL(4,1) function that doubles 0.123::DECIMAL(3,3) returned 0.2 (argument rounded to 0.1) on 1.5.6 and 2.0.0; a set with DECIMAL(4,1) and DECIMAL(9,3) overloads registers and every call fails "Could not choose a best candidate function". - types.md: an alias type is not a CREATE TYPE synonym: sum/abs/+ do not bind ("No function matches ... 'sum(pr_money)'"), =, < and max do; asserted in a doctest against the live engine, and measured on 2.0.0. - error-data.md: no callback API accepts an ErrorData. - table-functions.md: bind runs again on every EXECUTE on 2.0.0 (1 bind / 3 inits on 1.4.4 and 1.5.6, 4 binds / 3 inits on 2.0.0 for PREPARE + 3 EXECUTE); the typed builder scans on one thread at SET threads = 8 (measured on 1.5.6 and 2.0.0); the zero-column bind is an INTERNAL Error with a C++ stack trace without duckdb-1-5 on all three engines; the example no longer hard-codes 2048. - copy-functions.md: unknown/valueless/list COPY TO options are accepted silently (a built-in format rejects them), no column names in bind, format chosen from the file extension when it equals the format name. - arrow.md: a record batch with a root offset is refused. - running-sql.md: SET threads from a callback aborted 2.0.0 in 3 of 4 runs and failed 5 of 6 on 1.5.6. - AUTHT-1 (security): `std::fs` ignores `SET enable_external_access = false` and `allowed_directories`: read_csv and quack-rs's FileSystem get a Permission Error, a std::fs table function returns the file (1.5.6, 2.0.0). Stated in file-system.md (canonical section), table-functions.md, replacement-scan.md, copy-functions.md and the FAQ. Ran: book doctest, 254 passed / 0 failed / 5 ignored (live 1.5.6). * docs: pitfalls L20, L21, P16, P17 and the corrected L3/L11, known-limitations regrouped - LESSONS.md L3 said "Made impossible" and omitted that a raw callback is not guarded (DOCS-2); brought in line with the book. The six titles that differed from the book's (P2, P3, P5, P7, P9, P12) now match it, so the book's published anchors stay; scripts/check-pitfalls-parity.py (a patch for infra) passes on the 38 pitfalls. - L11 lists the crashing shapes as measured on 1.4.4, 1.5.6 and 2.0.0 (one process per shape, 5,000 and 300,000 rows): OVER (), explicit UNBOUNDED..UNBOUNDED ROWS/RANGE frames and agg(x ORDER BY y) segfault on 1.4.4 and 1.5.6; OVER (PARTITION BY p) without ORDER BY segfaults on 1.4.4 only; everything passes on 2.0.0. - New pitfalls with the P11-P15 structure: L20 duckdb_register_log_storage frees its extra data twice when the name is taken (re-run with the apigaps probe on 1.5.6 and 2.0.0: the destructor ran twice on one pointer; source read at v2.0.0 and main), P16 duckdb_get_bit/duckdb_get_bignum abort on NULL and non-castable values (SIGABRT on 1.5.6 and 2.0.0), P17 std::fs bypasses the sandbox settings, L21 a claimed-but-unwritten ChunkWriter row is published with stale contents (rule only, no API name). Pitfall count 34 -> 38 everywhere (README, intro, FAQ, contributing, ffi-reference). - known-limitations.md regrouped (what your extension must get right / DuckDB defects / what the C API does not offer / 2.0 changes / resolved), so resolved history no longer sits between current limits (DOCS-12); headings keep their anchors. Added: std::fs, table-in-out/progress/filter pushdown/ logging/secrets absent from v1, a quack-rs extension cannot be linked statically into a 2.0 host (read at v2.0.0), the five 2.0 changes missing from AUDIT 12.4, panics that cannot be caught. The C API v2 list named duckdb_v2_table_function_set_filter_pushdown, which does not exist (it is ..._callback); every name now cited was grepped in duckdb_v2.h. - docs/ffi-reference.md: its 12 uncompiled `rust` fences are `rust,ignore`/`text` with a note that they are sketches (patch 05 hunks). * docs: community-extension conformance in publishing.md (reserved names, function descriptions, ref keys, footer version, drifted statements); note on archived reports (The two historical reports docs/E2E_DOGFOOD_REPORT.md and docs/duckdb-v1.5.1-evaluation.md were moved to docs/archive/ in the previous commit: they already carried historical banners and nothing linked them; their relative links are fixed.) Every claim re-checked against the upstream file at the stated ref before it was written (raw.githubusercontent.com / duckdb.org, 2026-10-30): - Reserved names (CONFORM-3): extension_alias.cpp at v2.0.0 (10 aliases) and the 31 names of the 2.0 core-extensions table; `INSTALL s3 FROM community` on 2.0.0 fails "Failed to download extension httpfs ... (HTTP 404)", md and sqlite3 likewise (re-run). - function_descriptions.csv (CONFORM-7): scripts/generate_md.sh in community-extensions reads extensions/<name>/docs/function_descriptions.csv from that repository and left-joins it on function name, replacing description/comment/example; header seen in extensions/h3. - Revision keys (CONFORM-8): scripts/build.py selects andium for v1.4.5, variegata for v1.5.6, ref_next for other non-latest versions, else ref; DUCKDB_LATEST_STABLE is v2.0.0 in build.yml; it reads exactly the keys listed, everything else is ignored. - Footer version (CONFORM-9): configure_helper.py uses `git tag --points-at HEAD` else `git log -1 --format=%h`, not `git describe`; reproduced: no commit -> "error: malformed object name 'HEAD'", two tags -> two lines. - Drift (CONFORM-11): v1.5.6 and v1.5-variegata are different commits (ls-remote); the description.yml example is now the real scaffold output (license quoted, variegata comment); the Cargo.toml snippet gets rust-version/resolver; the matrix script differs per branch (Python modify_distribution_matrix.py on v1.5-variegata and v1.4-andium, Go extbuild on v2.0-cyanoptera). - CONFORM-14: reduced-CI flags from distribution_matrix.json (linux_amd64, windows_amd64, wasm_eh); `strip` on a stamped file exits 0 and LOAD then fails "The metadata at the end of the file is invalid" (run); requires_toolchains is matched as ;token;. * docs: SECURITY.md's supported versions are true for 0.20.0; MIN_RELEASE follows them (DOCS-13, HARDEN-10) What was wrong: the table listed 0.1.x and 0.2.x, which were never published, gave every 0.x line its own row, and said nothing about what the old releases carry; it named 0.19.x and 0.18.x as supported, which is not what the release this branch feeds (0.20.0) should say. Nothing tied the versioned book's MIN_RELEASE to the table (RELEASING.md Step 2b asked for it by hand). Change (the harden reviewer's patch 08 and the docs reviewer's patch 06, merged by hand; they conflicted): - supported: 0.20.x and 0.19.x; end-of-life: 0.18.x, 0.16.x, and 0.3.x - 0.15.x marked "do not use". Policy stated: the two newest minor lines, because Cargo treats a 0.x minor as a new major line, so `quack-rs = "0.19"` users never reach 0.20 by themselves and need the previous line fixed for one more cycle; 0.18.x ends with 0.20.0. This matches what the table already did (two lines) without inventing a date. - what releases before 0.16.0 carry, with version ranges checked in the published .crate files, not copied from either patch: from_bytes 0.3.0-0.15.0; get_file_path's free 0.8.0-0.15.0 (absent in 0.6.0/0.7.0: docs patch 06 said "0.7.0 through 0.15.0"); no ABI layout check with the duckdb-1-5 feature 0.4.0-0.15.0 (the feature exists from 0.4.0; harden said 0.8.0). None yanked. No 0.1.x/0.2.x on crates.io; no 0.17.x. - scripts/build-versioned-site.py MIN_RELEASE (0, 18, 0) -> (0, 19, 0), as RELEASING Step 2b requires in the commit that ends a line; the site drops /v0.18/ on the next docs.yml deploy. - scripts/check-release-metadata.py now fails while MIN_RELEASE differs from the oldest `| X.Y.x | Yes` line in SECURITY.md. Ran: crates.io API: 18 versions, oldest 0.3.0, newest 0.19.0, none yanked; the .crate files of 0.3.0, 0.4.0, 0.5.0, 0.6.0, 0.7.0, 0.8.0, 0.15.0, 0.16.0 extracted and grepped (features table; get_file_path's body; from_bytes's signature). check-release-metadata on this tree: agrees; copies with MIN_RELEASE left at 0.18, with 0.18.x marked supported again, and with 0.19.x dropped while Cargo.toml says 0.19.0: each exit 1 with the matching error. typos and ruff clean. Not run: the versioned-site build (this clone has no release tags). * Scalar bind data: report a panicking Clone, free a replaced value (FFI-6, FFI-12) FFI-6, what was wrong: ScalarBindData's copy callback returned null when T::clone panicked, and DuckDB's CScalarFunctionBindData::Copy then gave the copied expression no bind data: the query answered as if none had been set ((NULL, 0) instead of (4752, 32) in reviewer `ffi`'s filter-pushdown probe, VALIDATED on 1.5.6 and 2.0.0) and the panic message was lost. What changed: the allocation is a private Slot<T> (Value or CopyFailed with the panic message); all four of set/get/drop/copy are quack-rs-generated. A failed copy now yields a CopyFailed slot, never null. `get` reports it as the call's error through ScalarFunctionInfo::set_error (so the query fails with "... the bind data's Clone panicked ...: <message>") and returns None; `get_from_init` does the same through ScalarInitInfo::set_error; the new `try_get` returns the message as Err for a callback that wants to handle it (a later set_error in the callback would replace get's report; documented). FFI-12, what was wrong (documented, reviewer validated): a second ScalarBindData::set in one bind leaked the first value, because duckdb_scalar_function_set_bind_data is a plain assignment (read at v1.5.6 and v2.0.0) and the C API cannot read the pointer back. Fixed, as it was small: ScalarBindInfo remembers what ScalarBindData::set stored through it (a Cell), and a second set frees the replaced value after overwriting DuckDB's pointer. The raw set_bind_data clears the record (its pointers are the caller's, who may hand the same one back), so a value replaced through it, or through another wrapper of the same bind call, still leaks; documented on both. Tests: - unit: a_panicking_clone_is_reported_when_the_copy_is_read (replaces a_panicking_clone_yields_null_instead_of_unwinding, which pinned the bug), plus the copy/null tests moved to Slot. - live (scalar_bind_data_copy.rs): a_panicking_bind_data_clone_fails_the_query_with_its_message (get and try_get) - 1.5.6 passes; with 734bb15's src/scalar/state.rs (try_get swapped for get so it compiles) it fails "bomb_get: answered (None, 0) instead of failing"; setting_typed_bind_data_twice_drops_the_first_value - 1.5.6 passes; with the free removed (734bb15's behaviour) "left: 7 right: 9" (two leaked, one per bind). * docs: RELEASING.md matches what release.yml does: lockfiles, hotfix flow, secrets, summaries (DOCS-1, CI-1, CI-5, CI-15, HARDEN-9) What was wrong (ci, docs and harden reviewers; their patches 03, 08 and 08 conflicted on this file and are merged by hand): - Step 3 said "Do not update Cargo.lock manually" and Step 4 staged only CHANGELOG.md and Cargo.toml, while release.yml packages and publishes with --locked: following the runbook failed the release after all of CI (DOCS-1 High, CI-1). Four other lockfiles record quack-rs's version too. - The hotfix procedure tagged the hotfix branch and cherry-picked onto main afterwards; `validate` refuses a tag not on main, and a cherry-pick is a different commit (CI-5, simulated by the ci reviewer). - The fallback crates.io token was documented as a repository secret, readable by any workflow, so the crates-io environment's reviewer could be bypassed; no Trusted Publishing set-up order (HARDEN-9). - Appendix F mismatches: "each job writes a summary" (two do); "read the package job's summary" (it writes none); tags "annotated and signed" (only annotation is checked); Step 9's versions.json check is wrong for a pre-release; troubleshooting named deny.toml only; the crates.io hash check described as after-upload only. Change: TL;DR and Step 3 run `cargo update --workspace` in the root, examples/hello-ext, fuzz, book/doctest and benches/engine and commit the lockfiles in the same commit, saying why (--locked); Step 3b lists SECURITY.md, the README "latest" line, the two dates the grep cannot find (docs patch 08's note), and scripts/check-release-metadata.py; Step 4 stages every lockfile; Step 2b states the two-lines policy and that the script ties SECURITY.md to MIN_RELEASE; Step 5 says validate checks annotation, not the signature; Steps 6-7 describe the pre-upload hash check and the recorded rustc; the hotfix section merges the branch into main with a merge commit and tags the hotfix tip (ci patch 03's text, plus what to keep on main when the merge conflicts); Prerequisites take harden patch 08's environment-secret rows and set-up order (with its report's stop-gap step: move an existing repository secret into the environment); Step 1 names the four informational jobs, which may be red; troubleshooting covers a release-metadata failure, the CI-crates deny config and osv-scanner.toml, the pre-upload stop, and the environment secret. Ran: typos clean; shellcheck 0.11.0 on the 12 bash blocks: only the pre-existing `<run-id>` placeholder in Step 1 fails to parse. The commands were run elsewhere in this branch's verification: `cargo update --workspace --offline` in each lockfile directory changes exactly one line (the quack-rs version); check-release-metadata as described. The hotfix flow was simulated by the ci reviewer (scenario E2), not by me; the GitHub environment settings cannot be read from here. * docs: CONTRIBUTING states the sanitizer blind spot, the toolchain policy and DuckDB 2.0's agent mode; README/CONTRIBUTING match the workflows (LASTDIFF-3, CI-3, CI-15) What was wrong: - (LASTDIFF-3) The sanitizer jobs were described as answering "did we write outside an allocation"; the release libduckdb they link takes vector data buffers, LIST entry arrays and string heaps from its own jemalloc, which neither valgrind nor ASAN tracks, so a stale or out-of-bounds write there is invisible to them (the lastdiff reviewer's LASTDIFF-1 regression drew no valgrind report). - (CI-3) Nothing told a contributor that the toolchain is pinned, why, or how to move it; CONTRIBUTING said `rust-toolchain.toml` pins "stable", and "Python 3, any current" although two scripts now need tomllib (3.11). - DuckDB 2.0's CLI changes its output format when AI_AGENT or CLAUDECODE is set and stdout is not a terminal; nothing said so. - (CI-15, Appendix F) the workflows README did not mention the pre-upload hash check, listed benchmarks' triggers loosely, and did not say what check-ci-aggregate.py enforces now; CONTRIBUTING said CI runs "on every push"; the new hygiene/workflow-lint gates and the CI-crates deny run had no local command. Change: CONTRIBUTING gets "The Rust toolchain" (pin, exceptions, the informational look-ahead jobs, a three-step bump procedure) and "What the sanitizer and valgrind runs can and cannot see"; prerequisites name the pinned release, Python 3.11+, the hygiene tool versions, and the agent mode with the format flags that work (`-csv`/`-json` everywhere, `-no-agent` on 2.0 only); gate 6's toolchain sentence; gates 8 and 8b. The workflows README gets a "Pinning, and the checks that hold it" table and the upstream-guard semantics, the corrected rows, and two new steps for adding a workflow. ci.yml: comments only, on the leak-check and asan jobs, stating the blind spot (the jobs' steps are unchanged). Ran: `nm -D` on the release libduckdb.so: 769 `duckdb_je_*` exports at v1.5.6, 768 at v2.0.0, and no exported malloc/free/calloc/realloc. The DuckDB CLIs with AI_AGENT / CLAUDECODE set and stdout a pipe: 2.0.0 prints "duckdb agent mode on: ..." and a Markdown table (`| answer:INTEGER |`), `-csv` and `-json` override it, `-no-agent` restores the box; 1.5.6 shows no agent mode and rejects `-no-agent` (exit 1). scripts/check-hello-ext.py passes -csv (read). typos clean; actionlint clean; check-ci-aggregate reads the README table (37 blocking jobs). Not run: valgrind or ASAN myself; the jemalloc blind spot for ASAN follows from the same allocator (CONJECTURED for ASAN, VALIDATED for valgrind by the lastdiff reviewer). * docs: upgrade guide 0.18 -> 0.20, scaffold prerequisites, SQLLogicTest skip warning, README wrapped to 64 columns, governance reality - book/src/getting-started/upgrading-0-20.md (new, in SUMMARY and sitemap): every row traced to a CHANGELOG bullet of 0.19.0 or [Unreleased]; the 0.19 -> 0.20 section also covers the libduckdb-sys ceiling (<1.20100) and what a user of 0.18/0.19 can add themselves. - README: every code line is now <= 64 columns (the crates.io content column clips at about 64; checked by rendering the README at crates.io's width), the comparison table is shortened so its third column is no longer cut off. The quick start (TOML + lib.rs taken from the README text, quack-rs by path) builds on stable and on 1.86.0 with `--locked`, stamps, and loads on DuckDB 1.4.4, 1.5.6 and 2.0.0 with the printed table; double_it(9223372036854775807) is "Invalid Input Error: double_it: overflow". - scaffold.md: the scaffold generator is an example in the repository, not in the published crate (`exclude` has examples/); prerequisites for `make configure`; `make` ignores CARGO_TARGET_DIR (author-tables review). - testing.md: a SQLLogicTest file whose `require` fails is reported SKIPPED and exits 0 (conform review); the NULL example re…
Contributor
Author
|
Looks like these dependencies are no longer updatable, so this is no longer needed. |
dependabot
Bot
deleted the
dependabot/github_actions/actions-37e66268e9
branch
October 30, 2026 18:15
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Bumps the actions group with 3 updates in the / directory: dtolnay/rust-toolchain, Swatinem/rust-cache and rust-lang/crates-io-auth-action.
Updates
dtolnay/rust-toolchainfrom e2a55d2ffb04f378e9626c28d38b36d230d1e12f to 683b588c487a69d01f6c6ddf40f036ff682cc2c8Commits
683b588Add 1.99.1 patch releaseUpdates
Swatinem/rust-cachefrom 2.9.2 to 2.9.3Release notes
Sourced from Swatinem/rust-cache's releases.
Changelog
Sourced from Swatinem/rust-cache's changelog.
... (truncated)
Commits
d1527c82.9.3f0fca6fupdate dependencies and rebuildb49b17fadd missing awaits6a7bc3eBump the dev-minor group across 1 directory with 2 updates (#383)4ece996Bump the actions group across 1 directory with 6 updates (#392)8103affBump the prd-minor group across 1 directory with 2 updates (#389)0e361f3fix: log rustup toolchain list failure as info instead of warning (#393) (#394)f0d9c38Merge pull request #380 from Swatinem/dependabot/github_actions/actions-8ff58...ccd9742Bump the actions group with 2 updates258712bfix: stop cleanup timestamp pruning after the first entry (#377)Updates
rust-lang/crates-io-auth-actionfrom 1.0.5 to 1.0.6Release notes
Sourced from rust-lang/crates-io-auth-action's releases.
Commits
3268eb4Merge pull request #278 from marcoienibot/chore/update-dependencies-2026-10e901356chore(deps): update dependencies and GitHub Actions9c067fcMerge pull request #277 from rust-lang/renovate/msw-3.x9b55005chore(deps): update dependency msw to v34920f09Merge pull request #276 from rust-lang/renovate/major-github-actions04dcccbchore(deps): update github actions82864bfMerge pull request #274 from rust-lang/renovate/major-vitest-monorepo2bd8e07chore(deps): update dependency vitest to v5f14f407Merge pull request #271 from rust-lang/renovate/github-actions0205d6cchore(deps): update github actions