Release WorkTable 1.10.0 beta1

.github/workflows/rust.yml

@@ -5,6 +5,7 @@ on:
     branches: [ "master" ]
   pull_request:
     branches: [ "master" ]
+  workflow_dispatch:
 
 env:
   CARGO_TERM_COLOR: always
@@ -32,29 +33,75 @@ jobs:
     # exceeded 30 minutes when GitHub's cache service was unavailable. Keep
     # enough room for a real from-scratch release gate.
     timeout-minutes: 45
+    # Not on a pull request. `cargo test --workspace --all-targets` is a
+    # ten-minute compile on a two-core runner before it runs anything, three
+    # times over the matrix, and it is the same command `scripts/ci-local.sh`
+    # runs on a developer's machine in a fraction of that. Run it there.
+    #
+    # It still runs on master, which is what `publish` gates on, and on a manual
+    # `workflow_dispatch` when a change wants it earlier.
+    if: github.event_name != 'pull_request'
     strategy:
       fail-fast: false
       matrix:
         include:
           - name: default
             args: ""
+            test_debug: 2
           - name: versioned-publication
             args: "--features versioned-row-publication"
+            test_debug: 2
           - name: all-features
             args: "--all-features"
+            # Full DWARF makes Rust 1.98's bundled rust-lld crash while linking
+            # the large integration-test binary on a two-core runner.
+            test_debug: 0
 
     steps:
     - uses: actions/checkout@v4
     - uses: Swatinem/rust-cache@v2
       with:
         cache-on-failure: "true"
         add-job-id-key: "false"
-    - name: Build
-      run: cargo build --workspace --all-targets ${{ matrix.args }} --verbose
-    - name: Run tests
+    # There is no separate build step. `cargo test --all-targets` builds every
+    # target it is about to run, and the build step ran without
+    # `CARGO_PROFILE_TEST_DEBUG`: the two commands disagreed about the test
+    # profile, so the second one missed the first one's cache and compiled the
+    # workspace a second time. On the all-features leg it also compiled with the
+    # full DWARF that `test_debug: 0` is set to avoid, which is what makes
+    # rust-lld crash linking the integration-test binary on a two-core runner.
+    - name: Build and run tests
       run: cargo test --workspace --all-targets ${{ matrix.args }} --verbose
+      env:
+        CARGO_PROFILE_TEST_DEBUG: ${{ matrix.test_debug }}
 
 
+  # What a pull request gets instead of the full matrix: the library tests of
+  # every crate, without `--all-targets`.
+  #
+  # That leaves out the integration-test binary and the compile-fail harness,
+  # which is where the ten minutes live -- the trybuild tests shell out to
+  # nested cargo builds, and one of them alone took 56 seconds. The lib tests
+  # are the part that answers "did this change break something" quickly, and
+  # they are not a token gesture: the assertion that turned this whole workflow
+  # red was `worktable_dsl`'s `legacy_in_place_section_is_rejected`, a lib test
+  # this job runs and the fmt/clippy/no-std jobs all passed straight over.
+  #
+  # The full matrix still runs on master and on demand.
+  smoke:
+    name: Smoke test (lib tests)
+    runs-on: ubicloud-standard-2
+    timeout-minutes: 15
+    if: github.event_name == 'pull_request'
+    steps:
+      - uses: actions/checkout@v4
+      - uses: Swatinem/rust-cache@v2
+        with:
+          cache-on-failure: "true"
+          add-job-id-key: "false"
+      - name: Library tests (cargo test --workspace --lib)
+        run: cargo test --workspace --lib --verbose
+
   clippy_check:
     name: Clippy (${{ matrix.name }})
     runs-on: ubicloud-standard-2
@@ -81,6 +128,12 @@ jobs:
     name: Archived-row lock concurrency models
     runs-on: ubicloud-standard-2
     timeout-minutes: 15
+    # Not on a pull request. The models explore an interleaving space rather
+    # than run a suite, they build into their own CARGO_TARGET_DIR so they share
+    # no cache with any other job and pay a cold compile every time, and the
+    # answer does not change with a review comment. They still run on master,
+    # where `publish` gates on them, and on demand.
+    if: github.event_name != 'pull_request'
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable

CHANGELOG.md

@@ -1,6 +1,46 @@
 Change Log
 ==========
 
+## [1.10.0-beta1]
+
+### Changed
+
+- Declared mutations now use `update:` and
+  `update_in_place:`. They generate typed selector calls such as
+  `update_by_id(id, InvoiceColumns::AMOUNT, value)` and
+  `update_in_place_by_id(id, InvoiceColumns::STATE, edit)`. Multi-column
+  declarations expose one selector for their exact atomic field set and take
+  the generated query struct. Multi-column `update_in_place` declarations pass
+  a tuple of mutable archived fields to one closure, preserving the declared
+  atomic field set. Full-row replacement is now `replace(row)`.
+
+### Added
+
+- The frozen `LinearTable` and `VecTable` API is now part of WorkTable itself,
+  replacing the retired `worktable-vec` compatibility crate. PathDB's indexed
+  lookup compiles to instruction-for-instruction identical AArch64 code before
+  and after the move.
+
+### Fixed
+
+- Generated fixed-size primary-key wrappers now report their actual archived
+  alignment. A `u128` primary key previously under-budgeted each persisted WTI
+  entry, producing an 18,518-byte index archive for a 16,356-byte default inner
+  page; the corrected 16-byte alignment selects a capacity whose archive fits.
+
+- Dropping a persisted table with queued writes now joins its private writer
+  before the final handle disappears. An immediate same-path reopen can no
+  longer race detached writes and observe a partial store or torn index header.
+
+- Generated persisted-table startup now constructs its page storage directly
+  in the final `Arc` allocation and pins nested load futures before awaiting
+  them. This removes roughly 16 KiB page and directory temporaries from normal
+  thread stacks. In AgentCode's eight-table empty-store startup, the generated
+  load future shrank from 17,832 bytes to 2,392 bytes and the restart path no
+  longer overflows Tokio's default 2 MiB worker stack. Existing-page reads and
+  mutations are unchanged; fresh construction and page-growing inserts use the
+  new final-allocation initializer.
+
 ## [1.9.0-alpha1]
 
 
@@ -39,9 +79,8 @@ Change Log
 
 
 - **`queries:` on a `vec: true` table.** It was refused wholesale; it now
-  generates `update_<name>`, `delete_<name>` and `update_<name>_in_place` under
-  the same names the paged table uses, so a declaration reads the same either
-  way.
+  generates typed `update_by_<key>` and `update_in_place_by_<key>` dispatch,
+  plus declared delete methods, under the same names the paged table uses.
 
   These are named wrappers rather than a new execution path: a declared update
   is `update(&pk, |row| ..)` with the columns filled in from a generated struct,
@@ -198,15 +237,15 @@ Change Log
   declares 65,536 rows into a partition that holds 256), and `persist: true`,
   which a dense partition has no engine to honour.
 
-  It carries `queries:`. An `update` or `delete` query keyed by the primary key
-  generates the same method name against the same `<Name>Query` struct the
-  paged table generates, so a call reads identically; the signature does not,
+  It carries `queries:`. An `update` query keyed by the primary key uses the
+  same typed field-set selector as the paged table, and a multi-column selector
+  takes the same `<Name>Query` struct. The signature differs,
   deliberately, because there is no `.await` and no `WorkTableError`, and a
   call that moved between the shapes should fail to compile rather than
   quietly change what it guarantees. A query keyed by any other column is
   refused: a dense partition has no secondary index, and scanning it instead
-  would be a keyed operation silently becoming a linear one. `in_place` is
-  refused as a synonym, because every update here is already in place.
+  would be a keyed operation silently becoming a linear one.
+  `update_in_place` is refused, because every update here is already in place.
 
   Note that `memory_by_key` and `memory_total` **cannot see this saving**. They
   report `used_bytes`, which is rows plus indexes and excludes the fixed floor

Cargo.toml

@@ -3,7 +3,7 @@ members = ["codegen", "dsl", "examples", "performance_measurement", "performance
 
 [package]
 name = "worktable"
-version = "1.9.0-alpha1"
+version = "1.10.0-beta1"
 edition = "2024"
 authors = ["Handy-caT"]
 license = "MIT"
@@ -147,12 +147,12 @@ walkdir = { version = "2", optional = true }
 # These pre-release workspace crates move as one train. The explicit caret
 # keeps the dependency policy consistent while the local path selects this
 # checkout during validation.
-worktable_codegen = { path = "codegen", version = "^1.9.0-alpha1" }
+worktable_codegen = { path = "codegen", version = "^1.10.0-beta1" }
 # Re-exported below. Each generated table carries its declaration as a const
 # whose documentation says to read it with `worktable_dsl::Schema::parse`; that
 # instruction is only true if a plain `worktable` dependency can reach the
 # crate.
-worktable_dsl = { path = "dsl", version = "^1.0.0-beta.19", optional = true }
+worktable_dsl = { path = "dsl", version = "^1.10.0-beta1", optional = true }
 
 [target.'cfg(unix)'.dependencies]
 libc = { version = "^0.2", default-features = false }

README.md

@@ -113,7 +113,7 @@ for table in database.catalog().system_tables() {
 
 ```toml
 [dependencies]
-worktable = { version = "^1.9.0-alpha1", features = ["s3-support"] }   # S3 sync, optional
+worktable = { version = "^1.10.0-beta1", features = ["s3-support"] }   # S3 sync, optional
 ```
 
 Persisted indexes default to WorkTablesIndex. Vanilla IndexSet can be selected explicitly with `using indexset` while retaining the existing disk/S3 representation. Congee and Arctic persistence is experimental and uses their native checkpoint/WAL adapters; declarations using either backend must state `persist: true` or `persist: false` explicitly. The full syntax and capability matrix are documented in [Per-index backends with `using`](docs/index-backend-dsl-proposal.md).
@@ -426,7 +426,7 @@ There are some default query implementations that are available for all `WorkTab
   into grouped persistence operations, and durability follows the usual `wait_for_ops` contract. Autoincrement tables
   additionally get `reserve_pks(&self, count: usize) -> Range<RawPk>` to pre-assign contiguous keys to a batch;
 - `upsert(&self, row: <Name>Row) -> Result<(), WorkTableError>`;
-- `update(&self, row: <Name>Row) -> Result<(), WorkTableError>`;
+- `replace(&self, row: <Name>Row) -> Result<(), WorkTableError>`;
 - `delete(&self, pk: <Name>PrimaryKey) -> Result<(), WorkTableError>`;
 - `select_all<'a>(&'a self) -> SelectQueryBuilder<'a, <Name>Row, Self>`;
 
@@ -456,8 +456,13 @@ query.
 
 #### `update` query declaration
 
-`update` queries are used to update row's data partially. Default generated `update` allows only full update of the row.
-But if user's logic needs some simultaneous update of row parts from different code parts. `update` logic supports
+`update` queries update only the declared fields through a typed, table-scoped
+column selector. For example,
+`table.update_by_id(id, TestColumns::ANOTHER, value).await?` changes only
+`another`. A multi-column declaration exposes one atomic selector such as
+`TestColumns::NAME_AND_AMOUNT` and takes its generated query struct. The
+generated `replace(row)` method replaces the full row.
+When application logic updates disjoint parts of a row concurrently, `update` supports
 smart lock logic that allows simultaneous update of not overlapping row fields.
 
 #### `select_all` query declaration

benches/cases/full_featured.rs

@@ -123,7 +123,7 @@ fn update(c: &mut Criterion) {
                 another: format!("updated_{}", fastrand::u64(..)),
                 something: fastrand::u64(..),
             };
-            black_box(table.update(row).await)
+            black_box(table.replace(row).await)
         })
     });
 }
@@ -151,7 +151,11 @@ fn update_by_pk_query(c: &mut Criterion) {
             let query = AnotherByIdQuery {
                 another: format!("upd_{}", fastrand::u64(..)),
             };
-            black_box(table.update_another_by_id(query, id).await)
+            black_box(
+                table
+                    .update_by_id(id, FullFeaturedColumns::ANOTHER, (query).another)
+                    .await,
+            )
         })
     });
 }
@@ -179,7 +183,11 @@ fn update_by_unique_index_query(c: &mut Criterion) {
             let query = AnotherByVal1Query {
                 another: format!("upd_{}", fastrand::u64(..)),
             };
-            black_box(table.update_another_by_val_1(query, val1).await)
+            black_box(
+                table
+                    .update_by_val1(val1, FullFeaturedColumns::ANOTHER, (query).another)
+                    .await,
+            )
         })
     });
 }
@@ -200,8 +208,11 @@ fn in_place_update(c: &mut Criterion) {
     };
 
     c.bench_function("full_featured_in_place_update_val", |b| {
-        b.to_async(&rt)
-            .iter(|| async { table.update_val_by_id_in_place(|val| *val += 1, black_box(pk)).await })
+        b.to_async(&rt).iter(|| async {
+            table
+                .update_in_place_by_id(black_box(pk), FullFeaturedColumns::VAL, |val| *val += 1)
+                .await
+        })
     });
 }
 

benches/cases/non_unique_index.rs

@@ -91,7 +91,7 @@ fn update(c: &mut Criterion) {
                 value: fastrand::u64(..),
                 category: fastrand::u64(0..10),
             };
-            black_box(table.update(row).await)
+            black_box(table.replace(row).await)
         })
     });
 }

benches/cases/simple.rs

@@ -66,7 +66,7 @@ fn update(c: &mut Criterion) {
                 id: pk.into(),
                 value: fastrand::u64(..),
             };
-            black_box(table.update(row).await)
+            black_box(table.replace(row).await)
         })
     });
 }

benches/cases/unique_index.rs

@@ -156,7 +156,7 @@ fn update(c: &mut Criterion) {
                 test: fastrand::i64(..),
                 another: fastrand::u64(..),
             };
-            black_box(table.update(row).await)
+            black_box(table.replace(row).await)
         })
     });
 }

benches/cases/update_contention.rs

@@ -41,7 +41,7 @@ fn single_row_update_contention(c: &mut Criterion) {
                                 another: format!("upd_{}", fastrand::u64(..)),
                                 something: fastrand::u64(..),
                             };
-                            black_box(table_clone.update(row).await)
+                            black_box(table_clone.replace(row).await)
                         });
                     }
                     while join_set.join_next().await.is_some() {}
@@ -81,7 +81,11 @@ fn single_row_in_place_contention(c: &mut Criterion) {
                     for _ in 0..level {
                         let table_clone = table.clone();
                         join_set.spawn(async move {
-                            black_box(table_clone.update_val_by_id_in_place(|val| *val += 1, pk).await)
+                            black_box(
+                                table_clone
+                                    .update_in_place_by_id(pk, FullFeaturedColumns::VAL, |val| *val += 1)
+                                    .await,
+                            )
                         });
                     }
                     while join_set.join_next().await.is_some() {}

benches/common/mod.rs

@@ -53,7 +53,7 @@ worktable!(
         another_idx: another,
     },
     queries: {
-        in_place: {
+        update_in_place: {
             ValById(val) by id,
         }
         update: {

codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "worktable_codegen"
-version = "1.9.0-alpha1"
+version = "1.10.0-beta1"
 edition = "2024"
 license = "MIT"
 description = "Proc-macro companion crate for worktable: the worktable! macro and its derives."
@@ -26,7 +26,7 @@ proc-macro = true
 # a declaration. See its crate docs for why that needed a separate crate.
 # Name the reviewed prerelease while accepting compatible schema-model and
 # validator updates. Release checks verify the resolved generated API.
-worktable_dsl = { path = "../dsl", version = "^1.0.0-beta.19" }
+worktable_dsl = { path = "../dsl", version = "^1.10.0-beta1" }
 # Test-only. As a normal dependency this proc-macro crate put `rkyv` with its
 # default features into the graph, which turned on `rkyv/std` for the target
 # build too and dragged `ptr_meta` with it. The generated code names `rkyv`