Repository navigation
Release 0.20.0: the eighth review (fixes, tests, scaffold, CI, docs) - #150
Merged
Merged
Conversation
…und 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
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
…uard.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.
…e 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.
…I-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).
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
…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.
…t; 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.
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]).
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.
…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.
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).
….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).
… 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.
… 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).
… 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).
…EN-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 ...".
…e 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.
… 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.
…PS-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.
…T2-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.
… 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.
…T2-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.
…I-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).
…pe, 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).
…itations 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).
…s, 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;.
…SE 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).
…I-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).
…low, 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.
…igned part, 35 new tests, 4 fuzz targets TESTS-1 (High). lsan-suppressions.txt held `leak:libduckdb.so`. LeakSanitizer tests a suppression against every frame of an allocation stack and every handle DuckDB allocates has a libduckdb.so frame, so the leak-check job could not report a missing duckdb_destroy_*. Measured here with tests/lsan_probe.rs (nightly, -Zsanitizer=leak, prebuilt libduckdb 1.5.6): with the old file a leaked LogicalType and a leaked Value exit 0; with the rule removed both exit 23 with a leak report; the Rust-allocation control exits 23 under both. The suppression was not needed: the whole ffi_roundtrip suite (460 tests) exits 0 under LeakSanitizer with no rule. The file now holds a comment only, and the leak-check job has a step that leaks a Rust allocation, a LogicalType and a Value on purpose and requires a LeakSanitizer report each time (and a pass when nothing leaks). TESTS-9 (Low). abi::parse_version took a leading `+` in a part (`u64::from_str`). Digits only now; build.rs already had the same rule (HARDEN-12), its comment says so. property_inputs::parse_version_refuses_a_part_that_is_not_plain_decimal fails on ef97dd5 (minimal input `0.+0.0`, saved in the proptest-regressions file) and passes now. TESTS-3..7 (Medium). Tests that kill mutants the suite let live, found by exposing the bodies of `unsafe fn`s that cargo-mutants skips: wide_rows (u128 and every other fixed-width stride over 5,000 rows), vector_capacity_guard (MAP and UNION arms), 12 Arrow layout-walker unit tests, abi_policy_enforced (the `AbiPolicy` dispatch in-process against a v1.4.4 layout table), lifecycle_gaps (get_from_init, the two extra_info destructors, abi::check), connection_registrar (seven Registrar methods of Connection nothing executed), oracle_temporal (4,000 random values per check against DuckDB's own SQL). The reviewer's import_layout test a_list_far_into_its_child_converts_the_distance_between_its_offsets is dropped, not adapted: with the FFI-1 bounds check that layout (a list starting at element 2^40 of a 3-element child) is refused before the arithmetic it targeted, and list_offsets_outside_the_child_are_refused covers the refusal. Its dictionary shapes use dictionary_of() because Shape now carries `indices`. TESTS-13 (Low). Fuzz targets abi_version, append_metadata, description_roundtrip and scaffold_text, each with a seed directory (the fuzz job copies fuzz/seeds/<target>/ and would have failed without one). Each ran 60 s on the merged tree; description_roundtrip found a crash in its own escaping (PyYAML refuses U+007F even inside quotes, so the target must escape it) and ran 787,689 inputs clean after the fix. Not adopted: the reviewer's TESTS-8 patch (strip a leading `_` from every symbol). The tree already tells a Mach-O symbol table from an ELF one by its magic; the reviewer's repro input now produces no warning, and an ELF symbol `_my_ext_init_c_api` really is a different symbol DuckDB cannot load, which the blanket strip would have silenced. Ran: cargo fmt --check; clippy --all-targets -D warnings with default, duckdb-1-5-4 and bundled-test-prebuilt,duckdb-1-5-4; the new live modules on engine 1.5.6 (11 passed); property_inputs (10), abi_policy_enforced (1), import_layout (38, duckdb-1-5-4); documented_source_trees_match_the_filesystem. Not run: the new live tests on 2.0.0, 1.4.4 and 1.5.0-1.5.5. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
On 2.0.0, CAST(make_timestamp(m) AS VARCHAR) for m below -9223372022400000000 (except the -i64::MAX sentinel) raises an INTERNAL error (the `__cast` function "threw an execution error, but the function is not marked as fallible"), which TRY() does not catch; 1.x answers NULL. The first run of the reviewer's timestamp oracle on 2.0.0 (the reviewer had no 2.0 build) failed on it. On 2.0.0 those values are no longer put to the engine and are expected to be refused by the wrapper; the 1.x runs hold the engine to that answer. Ran oracle_temporal on 1.5.6 (4 passed) and on 2.0.0 with the 1.20000.1 bindings (4 passed). The rest of the live suite on 2.0.0 had passed except this one test (459 of 460 in ffi_roundtrip before this change). Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…an unreachable upstream on the weekly schedule
TESTS-10. The five scripts that compare a checked-in table with upstream
returned 2 ("could not check", a warning and a green job on a pull request) for
an HTTP 404 and for "the layout may have changed" as well as for an unreachable
network. Reproduced on the previous tree:
check-platform-table.py --ref this-ref-does-not-exist exited 2 with a warning.
If upstream renamed config/distribution_matrix.json, moved extension_entries.hpp
or reshaped licenses.json, the gate would have degraded silently and for good.
Now 2 means a network failure, a 5xx or a 429; an HTTP 4xx (other than 429), an
entry without duckdb_arch, an empty list, a registry without the expected key,
a header the autoload parser cannot read, a workflow without a toolchain pin and
every release answering 404 are 1. upstream-guard.sh also fails a 2 when
GITHUB_EVENT_NAME is schedule (it already did on a release tag), so a gate that
has not run for a week is noticed; its self-test has five more cases (14 in all, counted from the run).
Ran: upstream-guard.sh --self-test (14 cases ok); against live upstream,
platform (--ref this-ref-does-not-exist: exit 1, current ref: 0), spdx 0,
autoload --tags v1.5.5 0 and --tags v9.9.9 1, msrv 0, abi-table full 0 and
--tags v9.9.9 1. The old exit code (2) is measured only for the platform case
(the reviewer's repro); for autoload and abi-table it is read from the code
(HTTPError is a URLError; `if not rows: return 2`).
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…x test job instead of skipping TESTS-14. adversarial_text_round_trips_through_pyyaml, workflows_parse_as_yaml and the make-driven tests print "skipping" and return when the tool is absent; cargo test hides stderr, so a runner without PyYAML kept them green while checking nothing. QUACK_REQUIRE_TOOLS=1 turns the skip into a failure; ci.yml sets it on the Linux leg of the test job, after installing python3-yaml, make and git. macOS and Windows keep the skip (not verified whether those images have PyYAML). Shown with a stand-in python3 that reports "No module named 'yaml'": both tests pass with the variable unset and fail with QUACK_REQUIRE_TOOLS=1 (message names the tool); with the real python3 and PyYAML 6.0.3 they pass either way. The decision is a pure function with its own unit test. cargo test --lib scaffold: 108 passed (was 107). Not run: the Linux job itself (apt install step). Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…it, fix two comments TESTS-2 (High, documentation and tooling). cargo-mutants 27.1.0 generates no mutants inside unsafe fn bodies and never mutates integer literals, and nothing in the repository said so; the AUDIT's "0 missed" results never covered the pointer arithmetic. Measured on this tree with cargo-mutants 27.1.0 and --features duckdb-1-5-4: 2,488 mutants with .cargo/mutants.toml, 3,748 with --no-config; by the reviewer's heuristic script 506 unsafe fns hold 5,127 of 22,898 non-test lines (22.4%). On src/vector/reader.rs and writer.rs, mutants listed: 6 as is, 192 with the unsafe keyword removed from signatures, 344 with the literals wrapped as well, and the rewritten copy passes cargo check. CONTRIBUTING.md's mutation section now states the blind spot and where the live suite and the sanitizers stand in for it. scripts/mutants-expose-unsafe.py is the reviewer's mutprep.py and rsutil.py as one script (its output on vector/reader.rs is byte-identical to the original's); it is an audit aid for a copy of the tree and is not run in CI. The reviewer's other proposal, a CI job that runs it with the live suite, is not adopted: hours of runtime, and a text rewriter in the loop. TESTS-12/15. tests/ffi_roundtrip.rs said the Arrow module is run by the miri job (Miri cannot call foreign code; leak-check and asan run it); validity.rs pointed at tests/integration_test.rs for tests that live in tests/ffi_roundtrip/validity_api.rs and nested_validity.rs. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
TESTS-11. src/callback.rs was excluded wholesale as "macro-generated FFI wrappers", but catch_ffi_panic, panic_message, panic_c_message and message_to_c_string are plain functions (cargo-mutants cannot see inside the macros anyway). With the exclusion removed: cargo mutants --no-config --features duckdb-1-5-4 --file src/callback.rs --cargo-arg=--lib lists 5 mutants; 4 caught, 1 unviable, 0 missed (57 s). The configured list is 2,493 mutants (was 2,488). Not changed, for the owner: the full mutation sweep is workflow_dispatch only (no schedule), and the pull-request job runs --lib, so files whose mutants only a live engine can kill (those under exclude_globs) are not mutated in CI. The reviewer counted 42 such files on an older tree; not recounted here. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
The ceiling (<1.20100, below the DuckDB 2.1 bindings) is written in six places: the root manifest, examples/hello-ext, fuzz, benches/engine, book/doctest and the manifest the scaffold generates. every_manifest_states_the_same_bindings_requirement compares the five others with the root's. Negative control: changing fuzz/Cargo.toml to '>=1.4.4, <2' fails it, naming the file; restored, it passes. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
SqlMacro::register (32e8d64) reads the parser's message through it, so the allowlist's 'host-side' line was stale and scripts/check-api-coverage.py exited 1. Now: 546 slots at v1.5.6, 457 wrapped, 89 not used (8 candidate, 45 deprecated, 23 host-side, 13 superseded); exit 0. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
Cargo.toml and CITATION.cff say 0.20.0 (2026-10-30), README's latest line and the four remaining 0.19 snippets follow, and the CHANGELOG's [Unreleased] section is now [0.20.0] with the six work packages' entries, the tests-review entries and a Security entry for SqlMacro (SQLMACRO-1). Breaking items are marked inline. The book's changelog is synced; scripts/check-release-metadata.py passes (all five lockfiles, CHANGELOG heading and links, CITATION, README, SECURITY, snippets). Lockfiles: every one records quack-rs 0.20.0. Root: proptest 1.12.0 and cc 1.10.0 only (Dependabot #148); libduckdb-sys and duckdb stay at 1.10506.1. fuzz and book/doctest: cc 1.10.0 (#149). examples/hello-ext: libduckdb-sys 1.20000.1 (#143 asked for 1.20000.0, whose bundled engine reports v2.0.0-dev88614); it builds, and its 32 live checks pass on DuckDB 1.4.4, 1.5.6 and 2.0.0 (32/32 each), 43 unit tests pass. benches/engine/Cargo.lock is committed (.gitignore line removed, CI's deny and OSV steps and the release-metadata check no longer treat it as optional). hello-ext has 32 checks now (T30 added with the scaffold work); CONTRIBUTING, ci.yml and check-hello-ext.py said 31. The Performance table is re-measured with benches/engine/compare.py against a v0.19.0 export on this tree (1.5.6: 6 sessions x 3 runs; 2.0.0: 4 x 3); the ListBuilder NULL-element row is 10.72 ns, not the 8.60 the earlier table gave. Docs-link fixes: the oldest tag and crates.io release are 0.3.0 (checked with git tag and the crates.io API), so the dead 0.1.0/0.2.0 compare links are gone; the C-DEBUG link is the debuggability page (HTTP 200). Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
The book, the rustdoc and a few code comments named the review that made an
observation ("the author-tables review", "the conform review", reviewer `ffi`).
That is process, not information for a reader; the evidence labels stay (built and
loaded, read in the source and not run, observed in a review and not re-run).
Also checked against freshly generated projects: the scaffold chapter's file
tree (15 files), the v1.5.6 bindings pin (~1.10506.0 plus the duckdb-1-5-4
feature), the refusal of an unstable 2.x target, the dual-license file names and
the LICENSE.TODO fallback all match.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
… own differential numbers typos 1.46 flagged 'dictionarys' (a test name in the Arrow layout tests, renamed) and two deliberate 'SELEC' statements in tests/ffi_roundtrip/query_metadata.rs (allowed by pattern in typos.toml). typos now exits 0; actionlint with CI's -ignore SC2129 exits 0. The CHANGELOG's description.yml claim is now what I measured, not the work package's figure: a scratch crate calls parse_description_yml on the 395 descriptors of community-extensions 845779e and on 3 x 39,500 random mutants (deleted/inserted/replaced characters from a YAML-significant alphabet, line duplication, deletion, swaps, re-indentation, truncation) and compares with PyYAML 6.0.3 yaml.safe_load: originals 395/395 agree; mutants: 0 accepted that PyYAML refuses and 0 panics. The other direction was not classified: quack-rs accepts 18,398 / 18,080 / 18,426 of the mutants and PyYAML loads 24,846 / 24,501 / 24,820, and what separates them (description.yml validation rules, the work package's eight deliberate strictnesses) was not itemised here. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
cargo-semver-checks 0.51.0 against v0.19.0 (--release-type patch, features duckdb-1-5-4,_duckdb-testing) reports two breaking changes: the four enums that are #[non_exhaustive] (already listed) and ScalarBindInfo losing RefUnwindSafe, which FFI-12's Cell<Option<..>> field causes and nobody had listed. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…the live configuration sees Section 14 records the method (twelve reviewers, six work packages), the High findings with the evidence for each, the other findings by package with what is VALIDATED here and what is REPORTED, what was declined or rejected and why, the owner-only actions, what was not verified, the re-measured performance with spreads, the verification record for the final tree, corrections to earlier sections, and the process lessons. The header of the file and 13.7 point to it. tests/ffi_roundtrip.rs: LeakSanitizer in a doc comment needed backticks (clippy::doc_markdown), which fails clippy --all-targets only in the live configurations (bundled-test-prebuilt) because only they compile that file; found by running clippy there on the final tree. All four live configurations pass now. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
cargo test --doc --locked --manifest-path book/doctest/Cargo.toml against libduckdb 1.5.6 with the lock's 1.10506.1 bindings, RUSTFLAGS and RUSTDOCFLAGS -D warnings. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…, scaffold-e2e dependency line, wasm stack Run 711 (03cc120) failed in places the local gates cannot reach: - Windows: src/scaffold/tests_make.rs is Unix-only, but its helper functions were compiled and unused there, so -D dead-code failed the lib test build. The module is now declared #[cfg(all(test, unix))]. - macOS: a_file_name_that_is_not_utf8_is_used_not_a_panic cannot create its input (APFS/HFS+ refuse a non-UTF-8 name: EILSEQ, 'Illegal byte sequence'); it is gated to Unix without macOS. Names that are only arguments (no file) are still tested. - scaffold-e2e, 'C API v1.5.6' step: its regex wanted '{ version = ".." }' but the scaffold now writes '{ version = "0.20", features = ["duckdb-1-5-4"] }' for a v1.5.6 project; the step rewrites only the version into a path and asserts the feature is there. - wasm: the description.yml depth test recursed 64 levels in a debug build and ran out of emscripten's 64 KB default stack ('memory access out of bounds' in block::parse_seq); the unit-test step links with -sSTACK_SIZE=8MB. Verified here: actionlint (CI's flags), the scaffold unit tests and append_metadata_cli on Linux, clippy -D warnings. NOT verified: any of the four on the platform it is about; the next CI run is the check. Also seen in run 711 and not reproduced: a stack overflow in ffi_roundtrip against DuckDB 1.4.5 (the suite passes 3 of 3 here against the same 1.4.5 library and bindings, with CI's RUST_BACKTRACE=1). Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…et/ for the 2.0 source build
The informational Nightly job failed tests/build_script_env.rs: nightly Cargo
(1.101.0-nightly, 2026-10-23) lays a package out as build/<package>/<hash>/out/
(build_script_build, and the test binary itself in out/), not
build/<package>-<hash>/build-script-build. The old finder panicked 'Cargo compiled
quack-rs's build script for this test run' there (reproduced), and passes on
stable; the new one finds the script in both layouts (nightly and 1.99.1 both run
green here).
The informational 'bundled-test on the DuckDB 2.0 bindings' job stops in the build
script ('neither duckdb_extension.h nor duckdb.hpp is there') on a restored cache:
the 1.20000 bindings unpack DuckDB's sources into target/duckdb-sources/, which the
cache does not carry, while the build record it does carry says the sources are
there. The job now sets cache-targets: false so it builds from scratch. This is my
reading of runs 705 and 711 (CONJECTURED): the job needs a source build to confirm.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…indows dead code) CI run 716 (6005f64), Test (windows-2025): temp_files in src/bin/append_metadata/tests_output.rs is used only by Unix tests, so -D dead-code failed the bin's test build; the Path import became unused with it. Both are #[cfg(unix)] now. This one was the second of its kind (tests_make.rs was the first), so the rest was found locally: cargo check --all-targets with RUSTFLAGS='-D warnings' for x86_64-pc-windows-gnu (cfg(windows)) and aarch64-apple-darwin, with and without duckdb-1-5-4, using CC=true for the one C build script (criterion's alloca) that a check does not need. Both finish clean, and so does Linux. That checks that the code compiles there, not that the tests pass there. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…the nesting cap at its boundary instead The macOS source-build leg and, once, the Linux 1.4.5 leg aborted in `hostile_input::a_deeply_nested_type_is_refused_not_recursed_into` with a stack overflow. Cause, from a gdb backtrace of the old test on a 512 KiB stack (1.5.6, prebuilt): the test registered a scalar set whose overload parameter was 3,500 levels deep, and the next `register_table` ran its name check, a `duckdb_functions()` scan, in which DuckDB's own `LogicalType::ToString` recursed once per level. How much stack that needs depends on how DuckDB was built, so a 2 MiB thread was enough on a prebuilt library and not on every other build. The test itself left the trap in the catalog. The replacement stops at the cap (256, `table::type_check::MAX_TYPE_NESTING`) and asserts what the cap changes instead of whether the process survived: a scalar return type nested 256 levels registers and 257 is refused; a set whose two overloads differ only 300 levels down is refused as a duplicate (rendering stops at the cap) while 255 levels down they register; and a table function still registers after such a set. Checked by changing `MAX_TYPE_NESTING` and running the test on 1.5.6: with 100000 and with 255 and with 257 the scalar boundary assertions fail (the 257-deep type registers, or the 256-deep one is refused); with the scalar block reduced to its passing case, 100000 fails the set assertion. The new test passes with RUST_MIN_STACK down to 384 KiB and overflows at 256 KiB on 1.5.6; unrelated tests in the file pass at 128 KiB. The full `ffi_roundtrip` binary passes on 1.5.6 (460 tests), 2.0.0 (460), 1.4.5 (308, three runs) and 1.4.4 (308). The old test also passed on 1.4.5 locally, so that run does not discriminate; the backtrace and the mutation runs do. The macOS source build itself was not run here. `MAX_TYPE_NESTING`'s documentation now says what the overflow involved and that a type past the cap is refused with the ANY/INVALID message. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…ut of the limit `cargo llvm-cov` (the Coverage workflow) failed on 928b1a8 with "invalid instrumentation profile data (file header is corrupt)" and "no profile can be merged", although every test passed. Reproduced locally with `cargo llvm-cov llvm-cov --no-report` on the prebuilt 1.5.6 engine: of 91 profile files exactly one failed `llvm-profdata show`, 4096 bytes long; its name carried the signature that `append_metadata` writes (found by running the binary with LLVM_PROFILE_FILE set), and the other 14 files with that signature are 42,888 bytes. The file is the instrumented child of `a_failed_write_leaves_nothing_behind_and_names_the_output`, which runs `append_metadata` under `ulimit -f 8` (a 4 KiB file limit) to provoke EFBIG: the profile the child writes on exit is cut off at the limit. The child now writes its profile to /dev/null, which the limit does not apply to. After the change the same test binary under cargo-llvm-cov leaves 15 profile files, all accepted by `llvm-profdata show`, and the full `cargo llvm-cov --all-targets --features bundled-test-prebuilt,duckdb-1-5-4 --lcov` run exits 0 with 1,789 tests passed, 0 failed, and an lcov file covering 160 source files. The workflow itself uses `--all-features` (the source-built engine), which was not run here. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
… does not race on the extension directory On 2be944d the windows-2025 bundled-test job ran `ffi_roundtrip` to the end (the stack overflow of 928b1a8 is gone there) and 457 of 458 passed. The failure: the_name_validator_accepts_every_name_duckdb_does: SELECT DISTINCT extension_name FROM duckdb_extensions(): IO Error: Cannot open file ".../v1.5.6/windows_amd64/parquet.duckdb_extension.tmp-<uuid> .duckdb_extension.info": The process cannot access the file because it is being used by another process. That is another thread's install of `parquet` in progress: a source-built DuckDB has no parquet, and the only test that asks for it is `table_cast::registering_a_taken_copy_function_name_is_an_error`, which registers a COPY format named "parquet" (my reading; the Windows run is not reproducible here). It is the race `install_icu_once` already removed for ICU ("Could not move file: Access is denied"). The helper is now `install_extensions_once` and runs `INSTALL icu` and `INSTALL parquet` inside the same `call_once`, so every other fixture waits for the installs and only loads. A library that carries the extension treats INSTALL as a no-op, and a failed install (no network) is ignored as before. The doc comment that belonged to `Fixture` had ended up on the helper; it is back on the struct. Checked here: the full `ffi_roundtrip` binary passes on 1.5.6 (460), 2.0.0 (460) and 1.4.5 (308), and clippy -D warnings is clean in the live configuration. These are all prebuilt libraries, where the change is a no-op, so they show nothing about the race itself; whether it is gone is the windows-2025 job's answer. Of the 58 jobs of run 724 on 2be944d, 56 succeeded, this one failed and Miri was still running when I read them. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…aught Nine problems that appeared only on GitHub's runners after the local gates passed, none needing a change to the shipped library code: Windows dead code, the macOS non-UTF-8 file name, the scaffold-e2e dependency line, the wasm stack, the nightly build-script layout, the DuckDB 2.0 source-build cache, the deep-type test (cause from a gdb backtrace, plus the limitation that a parameter type past the 256-level cap still registers), the Coverage profile truncated by `ulimit -f`, and the Windows extension-directory race. The Windows race fix is recorded as unconfirmed: the windows-2025 job decides. 14.10 gains three lessons: assert outcomes rather than survival, coverage changes what children do, and compare a check's head with the branch head before reading its failure. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…nse_terms unable to hang The Mutation Testing (incremental) job on 4036f7a reported twelve missed mutants in changed code before its runner shut down at 33 minutes: `parse_version::decimal` (`||` to `&&`), the "v1.5.6" and "v1.4.5" arms of `warn_about_the_community_build_of_an_unstable_binary`, `license_files` (`||` to `&&` in the split), five in `templates::quack_rs_feature` and two in `templates_docs::license_terms`. Tests that kill them: - `abi::tests::parse_version_refuses_a_plus_sign_in_any_part` - `the_unstable_binary_warning_names_the_ref_the_release_is_submitted_as` (the other two messages also mention repo.variegata, so only the whole sentence tells them apart) - `the_quack_rs_feature_follows_the_release_the_project_is_stamped_for` - `a_parenthesised_license_is_split_into_its_identifiers` - `a_license_with_an_exception_is_allowed_as_one_term`, and two assertions in the existing deny.toml test. Running cargo-mutants 27.1.0 with the job's flags on those five files (`--re` on the five functions, 59 mutants) found three more survivors in `license_terms` (`i + 1` to `i - 1` and `i * 1`, `==` to `!=`), which the job had not reached, and, after the first fix, three mutants that made the `i += n` loop run forever (timeouts, which the gate counts as failures). `license_terms` now walks the tokens with a peekable iterator, so every pass takes a token and none of its mutants can hang. Results: before the rewrite, 59 mutants in the five functions gave 44 caught, 12 unviable and 3 timeouts, no survivor; after it, `license_terms` alone (8 mutants) gave 5 caught and 3 unviable. The other four functions were not re-run after the rewrite, which does not touch them. The job generated 1,655 mutants for this pull request and had tested a fraction of them when it stopped, so this is not the whole picture; a local sweep of all changed files follows. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…were reachable Run 41048719895 on 1249dc4: 57 of 59 jobs succeeded, `Miri (undefined behaviour)` was cancelled and so `CI passed` failed. The job's two steps run in sequence under a 60-minute limit: the native step took 41.6 minutes (11:34:27 to 12:16:03) and the s390x step was cancelled 18 minutes in, when the job's hour ran out. The gaps between consecutive "test ... ok" lines in that step's log (tests run in parallel, so this attributes wall time, not CPU) put 1,086 s on `tests_pyyaml::deep_nesting_is_an_error_not_a_stack_overflow` (100,000-level inputs through a parser with no `unsafe`) and 160 s on `spdx::sibling_groups_do_not_count_towards_the_nesting_limit`. Under Miri those two use 1,000 levels and 3 groups, as `spdx.rs` already did for its other deep-nesting test; natively they are unchanged. Both versions pass here: full size natively, and the Miri-sized one run natively with RUSTFLAGS="--cfg miri". The job's limit goes to 90 minutes: by the same log the rest of the native step is about 21 minutes, so the two steps should need about 45, but I have not run Miri locally and the first run on this commit is the measurement. The Mutation Testing (incremental) job on the same head tested part of the 1,639 mutants before its runner shut down at 55 minutes and reported six survivors: - `scalar/builder/collision.rs` `overload_key`, `c == '_'` to `!=`: the test now has `x_DECIMAL(4,1)` and `x_MAP(a, b)`, which an underscore must keep. - `scaffold/tests_make.rs` (`have`, three mutants): that module is declared `#[cfg(all(test, unix))]`, which cargo-mutants does not recognise as test-only and so mutated its helpers. It is `#[cfg(test)]` plus `#[cfg(unix)]` now. - `LogicalType::refuse_where_the_engine_lacks` (two mutants) needs a live engine for `abi::engine_version`. Applied by hand against libduckdb 1.5.6, `timestamp_tz_ns::the_type_id_is_reported_for_a_column_and_creatable_only_where_it_exists` passes unmutated (5 of 5 tests) and fails with the body replaced by `Ok(())` and with `==` changed to `!=`. It is excluded from the --lib gate in `.cargo/mutants.toml` with that evidence, like its neighbour `try_new`. Not claimed: the job cannot finish on this pull request (1,639 mutants at about 20 s each over 4 jobs is about 2 hours against a 60-minute limit, and its runner stopped at 33 and 55 minutes in the two runs), so a green mutation check here is not expected. A local sweep with the job's flags over all 102 changed files is running; its results will follow. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
The incremental job mutates the whole of every source file a pull request
changes. For 0.20.0 that is 102 files and 1,639 mutants at about 20 s each; one
job over 4 threads needs about two hours against a 60-minute limit, and its
runner was stopped after 33 and 55 minutes in the two runs, with a handful of
survivors reported and the rest untested.
`mutants-incremental` is now a matrix of eight jobs, each running
`cargo mutants --shard k/8 --sharding round-robin` (mutant i goes to shard
i % 8, so the slow files spread over all of them; the default `slice` would
hand each shard a consecutive run in file order). Each shard runs the same
report gate as before and uploads its own artifact. A new job,
`mutants-incremental-gate`, is named "Mutation Testing (incremental)", the name
of the job it replaces, and fails unless every shard succeeded; it runs under
`always()` so a failed shard turns it red, since a skipped required check would
count as passed. `fail-fast` is off so one shard's survivor does not hide the
others'. The shard count is `strategy.job-total`, passed through `env:` like the
changed-file list, so the matrix and the command cannot disagree.
Checked locally with cargo-mutants 27.1.0 and the job's flags on a small
selection: shard 0/9 and shard 8/9 of 16 mutants ran two and one mutants, and
`mutants.json` in each lists only that shard's mutants; with 5 mutants over 9
shards shard 8/9 found none, exited 0 ("No mutants found under the active
filters"), and `scripts/mutants-report.sh incremental` accepted it (it fails an
empty run only in `full` mode). `actionlint`, `zizmor --offline`,
`check-workflow-expressions.py` and `check-action-pins.py` pass. Not run: the
workflow itself, so the eight-job matrix, the gate job and the artifact names
are untested until GitHub runs them; each shard of this pull request should
take about 205 mutants x 20 s / 4 = 17 minutes plus setup, an estimate from the
earlier job's timings. CONTRIBUTING.md describes the sharding and how to run
one shard locally.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
The first sharded run of the incremental mutation job (run 41067402973 on adfde73) reported `bounds.rs:172:13` as a survivor: `size < 0` changed to `size <= 0` in `list_view_entry` passed every unit test, because the tests used only sizes of 1 and above and negatives. The new test checks the boundary directly: (offset, size) of (0, 0), (0, 3), (3, 0), (i64::MAX, 0) and (0, i64::MAX) are accepted, and (-1, 0), (0, -1), (i64::MIN, 0), (0, i64::MIN) are refused. `cargo mutants` with the job's flags on `list_view_entry`: 7 mutants, 7 caught (the survivor among them). The other 101 survivors of that run are in the description.yml YAML reader and are being worked separately. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…ue_len, and progress guards The first sharded mutation run (run 41067402973 on adfde73) tested 1,617 mutants and left 102 (85 missed, 17 timed out); 101 were in the YAML reader added in this release. Working them from PyYAML 6.0.3's verdicts found three places where the reader was wrong: - A block scalar lost the lines after a blank line when the next line was a `#` line indented as far as the text: `description: |`, `l1`, a blank line and `# c` read as `l1`, PyYAML reads `l1\n\n# c\n`. `value_len` looked past every comment for the next content line. It is now a linear scan whose "run" is the blanks and the comments at the key's level or shallower, which also replaces the memo that made a run of k blank lines cost k^2 steps and drops a parameter (`seq_at_key_level`) that all three callers passed as `false`. - An anchor on a line of its own followed by a sequence at the key's indentation (`k:\n &a\n- x`) was refused; PyYAML reads `{k: [x]}`. `on_following_lines` forced `seq_at_key_level: false` on the value it re-parses; it keeps the key's. - A quoted key was measured without the spaces before its colon, so a key PyYAML refuses at 1,024 characters was accepted. The measure is now to the colon, as for a plain key; the `check_code` call on the spaces before it is gone (a slice of spaces cannot fail it). Checked with a three-way comparison (the original reader, the fixed one, PyYAML `safe_load`) built from the final tree: on 16,195 mutated published descriptors the two readers agree on every one and neither accepts a file PyYAML refuses; on 624 grid documents around anchor lines and quoted keys of 1,020 to 1,025 characters the fix repairs 34 and breaks none; on 14,874 documents with block scalars, comment-like lines and plain, quoted and flow values the `description` read equals PyYAML's wherever both accept (200 differed before), 474 more verdicts match and none matches less. The fixed reader still refuses what PyYAML accepts in two cases, unchanged by this commit: a tab-only content line in a block scalar, and a tag alone on a line (`k:\n !!str`). Regression tests: `tests_pyyaml.rs`, each fails on the original reader and passes now. The 17 timeouts were loops that spin when an index update is mutated. Each loop (`skip`, `seq`, `map`, `plain` in flow.rs; `parse_mapping`, `parse_seq` in block.rs; `split_lines`) now has a `debug_assert!` that a round made progress, so the mutant fails where it used to hang; release builds are unchanged. `split_comment` returns whether there is a comment instead of its text, which no caller read (the `i * 1` mutant could not be told from the original). Local `cargo mutants` over the functions that changed or had survivors (195 mutants): 184 caught, 11 unviable, 0 missed, 0 timed out; `split_comment` and `strip_comment`: 13 of 13 caught. 1,119 library tests, clippy and rustdoc clean, `cargo +1.86.0 check` (with CI's fallback resolver) passes with and without `duckdb-1-5-4`. The other mutants of those files are for the next sharded run. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…n left, and AUDIT 14.8 Four modules, `tests_mut_flow_a`, `tests_mut_flow_b`, `tests_mut_block` and `tests_mut_scalar`, written by four engineers (subagents, each in its own worktree) from the survivors of run 41067402973. Each row's expectation is PyYAML 6.0.3's verdict, checked with `yaml.safe_load` / `yaml.compose`; rows that pin the reader's own documented limits are commented as such (nesting of 64, no anchors in a field the reader reads, no explicit `? ` keys, error wording where accept/refuse is identical). Each engineer ran `cargo mutants` on its mutants before and after and reported the survivors that stayed. Together with the regression tests of the previous commit they killed 79 of the 85 missed mutants; the other six were four equivalents (their code is gone) and two PyYAML disagreements (fixed). AUDIT.md 14.8 gains items 10 (the Miri time limit) and 11 (the mutation job and what its first full run found), and 14.10 two lessons: random mutation of valid files is weak at a hand-written parser's edges, and what made the delegated sweep work. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
`typos` read the anchor name `anc` in tests_mut_flow_a.rs as a misspelling
of `and`; the anchor is now `k1` (PyYAML loads the document as
{'k1': 1, 'f': ['a', 1]}). The new tests_mut_*.rs modules were missing from
the source trees in CONTRIBUTING.md and book/src/contributing.md, which
documented_source_trees_match_the_filesystem compares with the filesystem.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
…nd fit in 1,024 characters
Inside a flow collection PyYAML takes a node for a mapping key only if the
`:` after it is on the key's own line and at most 1,024 characters from where
the key began, an anchor in front of it included. Otherwise the `:` is left
with no key and the parser stops at it ("expected ',' or '}'"). The reader
checked neither, so `k: {a` with `b: c}` on the next line, `k: [a` with `b: c]`
on the next, `{"a"` with `: c}` on the next, and a key of 1,025 characters were
accepted in a section it only checks (and the mapping form in `extension:`).
Found by checking an engineer's remark that PyYAML refuses `[a` / `b: c]`:
the reader refused that file only because `extension:` takes no nested flow
collections. `Cursor::check_key_extent` measures from the key's first
character (a `(segment, offset)` taken before the node is read, so an anchor
counts) to the `:`, as the block-key check already does.
Checked with a differential harness against PyYAML 6.0.3: 30,120 documents
(random token soup over brackets, braces, quotes, anchors, aliases, colons and
line breaks, plus keys at the 1,024 boundary in both collections and for plain,
quoted and anchored keys) gave 109 disagreements before, every one a file only
PyYAML refuses, and none after, with none newly refused and no panic. Two new
tests in tests_pyyaml.rs (16 short rows, 30 boundary rows; expectations are
PyYAML's) fail on the old reader and pass on the new. `cargo mutants` on the
functions touched: 38 mutants, 38 caught. Local gates: tests 1,152 (default)
and 1,293 (`duckdb-1-5-4`), doc tests 235, clippy, fmt, typos, taplo, deny.
CHANGELOG (and the book copy) and AUDIT 14.8 item 11 record it.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP
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.
Summary
Version 0.20.0, built from an eighth review of the whole repository: twelve reviewers (soundness, the diff since 0.19.0, C API gaps, community-extension conformance, docs, CI and supply chain, hardening, the FFI boundary, two author passes, dependencies, the test suite), then six work packages that fixed what they found, each merged with its own tests.
AUDIT.mdsection 14 has the evidence, what was declined, what is for the owner, and what was not verified.CHANGELOG.mdhas the entries; Breaking: items are marked inline and "Upgrading from 0.18 to 0.20" in the book lists each with what to do.Two High-severity defects were found and fixed before release: a segmentation fault in an unpublished
ListBuilderoptimisation, andSqlMacro::registerexecuting statements ahead of a parse error on DuckDB 2.0.0 (present since before 0.19.0; see Security in the CHANGELOG).Type of change
Breaking (all in the CHANGELOG): the entry-point macros refuse
panic = "abort";AbiCheck,AbiPolicy,ConfigOptionScope,TlsVersionare#[non_exhaustive];ScalarBindInfois no longerRefUnwindSafe; registration is transactional (Registration::Autocommitrestores the old behaviour); a zero-argument aggregate no longer registers;generate_scaffoldandparse_description_ymlrefuse inputs they used to accept;libduckdb-sys/duckdbare>=1.4.4, <1.20100(were<2).Checklist
Code quality
cargo test --all-targets(1,152 pass; 1,293 withduckdb-1-5-4) andcargo test --doc --features duckdb-1-5-4(235 pass, 3 ignored), run locally on the final treecargo clippy --all-targets -- -D warnings: default,duckdb-1-5,-3,-4;cargo fmt;cargo doc --no-depswith and withoutduckdb-1-5-4; typos, taplo, machete, cargo-denyunsafeblocks carry// SAFETY:; SPDX header on new filessrc/copy_function/info.rs)Testing
unsafe fnbodies, literals, macros) are documented in CONTRIBUTING.md.Documentation
CHANGELOG.mdupdated and the book copy synced (scripts/sync-book-changelog.py --check)scripts/check-release-metadata.pypassesSafety
unsafe_op_in_unsafe_fnstill deniedcargo checkpasses with and withoutduckdb-1-5-4What CI confirmed on the final head (7627f84)
CI (pull-request and push runs), Coverage and Mutation Testing all pass. In CI: tests on ubuntu, macOS and Windows (default features,
bundled-test, and theduckdb-1-5/-3/-4feature sets); end-to-end tests against libduckdb 1.4.4, 1.4.5, 1.5.0, 1.5.3, 1.5.4, 1.5.5 and 2.0.0; extension load tests against 1.4.4, 1.5.0, 1.5.5, 1.5.6, 2.0.0 and latest; the hello-ext example and its symbol check on three platforms; WebAssembly (emscripten); Miri (native and big-endian s390x); AddressSanitizer; LeakSanitizer; fuzz smoke; semver-checks; the dependency floor; cargo-deny and OSV; the scaffold end to end; the mdBook build; a publish dry-run.CI found problems that local runs had not, all fixed on this branch and recorded in AUDIT 14.8: a test that recursed into the engine's type printer and aborted on three platforms; coverage profiles truncated by an
ulimit -ftest; a Windows race on DuckDB's extension directory; a mutation job that needed more than its 60 minutes (now sharded); a Miri job that needed more than its limit (now 90 minutes); and my own new test files trippingtyposand the documented source tree.The sharded mutation run found 102 surviving mutants, 101 of them in the
description.ymlreader. They led to four places where the reader disagreed with PyYAML 6.0.3: block-scalar comment lines, an anchor line before a key-level sequence, quoted-key length with spaces before the colon, and a flow-collection key that is not on one line with its:or is over 1,024 characters. Each has a regression test whose expectation is PyYAML's verdict.Known limits, not fixed
MAX_TYPE_NESTING(256) bounds quack-rs's own type walks only. DuckDB's type printer recurses too, so an extension that builds types from untrusted input must bound their depth itself (documented on the constant).For the owner (nothing done)
Yank 0.3.0–0.15.0 and file RustSec advisories; Trusted Publishing and the
crates-ioenvironment; the upstreamduckdb_register_log_storagedouble free; Cloudflare email obfuscation; confirmCI passedis the required check. Details in AUDIT 14.5. Dependabot #143, #148, #149 are folded in by hand (#145 earlier) and should close as superseded. DuckDB 2.0.1 is due 2026-11-18; a patch release after it is planned.🤖 Generated with Claude Code
https://claude.ai/code/session_01EAuNU9xPW522tZ37enhFzP