tigerbeetle 0.0.37 → 0.0.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 552e8ed13e850cd27f9b0516763a3151939d0b13dcb7615cb9e562a1f5ec8ff8
-  data.tar.gz: 469bab9414b812cf7a65d2312362706725d7c30071c05691dd835cf2510d2ba0
+  metadata.gz: 55a5b0b68111a9aeac3084772fb0f0ad185a67d9f41c67b5bcd6392fd7fcab61
+  data.tar.gz: '03976907f14a64b11b0fd9f7bf0693a4f44a887b997b34c9912bc71b1653eea5'
 SHA512:
-  metadata.gz: e0a9f6179ead5c9fc058e0168fac1edd5c4fbd07bb5376387f37110b43f3a7d26c3ec9502bcfb6e34c97dae856fb570d76f6bda5c0459652e4601ed82e627d65
-  data.tar.gz: 9634608bd3eb31963cb5f02007bebd8fcf926982dac54f74e1a306b57383677731417e7f86d01cb832e6d06d4c60c6f694135fb86b0060d1d726c74d07201867
+  metadata.gz: 8c256706f6343e8e3d0cc1d130482009b28cdcc696ababa97a0d75f4fb7b74e7aa880fa364cb0ff55e274e26b876242f5f3418e6090f9e5dd5bdf17698252737
+  data.tar.gz: 7683f0b905a05ec28a2b164bc8a18f285ef64be2b6190ae40503b8f9ade3864238047ac5f53e6e0c5c60e94347a1483b1ad8a1b79221ae688941673bade1f82a

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.0.38
+
+- Based on TigerBeetle 0.16.74
+
+
 ## 0.0.36
 
 - Based on TigerBeetle 0.16.73

data/ext/tb_client/tigerbeetle/src/clients/c/tb_client/context.zig

@@ -23,6 +23,10 @@ const Message = MessagePool.Message;
 const Packet = @import("packet.zig").Packet;
 const Signal = @import("signal.zig").Signal;
 
+const KiB = stdx.KiB;
+
+const io_thread_stack_size = 512 * KiB;
+
 pub const InitParameters = extern struct {
     cluster_id: u128,
     client_id: u128,
@@ -351,7 +355,11 @@ pub fn ContextType(
             context.client.register(client_register_callback, @intFromPtr(context));
 
             log.debug("{}: init: spawning thread", .{context.client_id});
-            context.thread = std.Thread.spawn(.{}, Context.io_thread, .{context}) catch |err| {
+            context.thread = std.Thread.spawn(
+                .{ .stack_size = io_thread_stack_size },
+                Context.io_thread,
+                .{context},
+            ) catch |err| {
                 log.err("{}: failed to spawn thread: {s}", .{
                     context.client_id,
                     @errorName(err),

data/ext/tb_client/tigerbeetle/src/direction.zig

@@ -1,3 +1,25 @@
+const std = @import("std");
+const stdx = @import("stdx");
+const assert = std.debug.assert;
+const maybe = stdx.maybe;
+const Elem = std.meta.Elem;
+
+const binary_search = @import("lsm/binary_search.zig");
+
+/// LSM Tree is a sorted array with a monocle and a top hat.
+///
+/// We want to iterate it in both directions:
+/// - For CDC, you want to learn about all new objects with timestamp>threshold.
+/// - For paginated timelines, you want to learn about past objects with timestamp<threshold.
+///
+/// Sadly, this can't be implemented via just a single branch near the end of the system, we need to
+/// change a whole bunch of `<` to `>` throughout the stack.
+///
+/// Direction encapsulate the logic of "if ascending use < if descending use >". The mnemonic is
+/// that usual comparison is horizontal along a number line, but Direction-aware is vertical.
+///
+/// In other words, `key_min` and `key_max` track natural ordering, while `key_lower` and
+/// `key_upper` are direction-aware.
 pub const Direction = enum(u1) {
     ascending = 0,
     descending = 1,
@@ -8,4 +30,91 @@ pub const Direction = enum(u1) {
             .descending => .ascending,
         };
     }
+
+    pub inline fn cmp(
+        d: Direction,
+        a: anytype,
+        comptime op: enum { @"<", @"<=" },
+        b: @TypeOf(a),
+    ) bool {
+        return switch (op) {
+            .@"<" => switch (d) {
+                .ascending => a < b,
+                .descending => a > b,
+            },
+            .@"<=" => switch (d) {
+                .ascending => a <= b,
+                .descending => a >= b,
+            },
+        };
+    }
+
+    pub inline fn lower(d: Direction, a: anytype, b: @TypeOf(a)) @TypeOf(a) {
+        return if (d.cmp(a, .@"<", b)) a else b;
+    }
+
+    pub inline fn upper(d: Direction, a: anytype, b: @TypeOf(a)) @TypeOf(a) {
+        return if (d.cmp(a, .@"<", b)) b else a;
+    }
+
+    pub inline fn slice_peek(d: Direction, slice: anytype) *const Elem(@TypeOf(slice)) {
+        assert(slice.len > 0);
+        return switch (d) {
+            .ascending => &slice[0],
+            .descending => &slice[slice.len - 1],
+        };
+    }
+
+    pub inline fn slice_pop(
+        d: Direction,
+        slice: anytype,
+    ) struct { Elem(@TypeOf(slice)), @TypeOf(slice) } {
+        assert(slice.len > 0);
+        return switch (d) {
+            .ascending => .{ slice[0], slice[1..] },
+            .descending => .{ slice[slice.len - 1], slice[0 .. slice.len - 1] },
+        };
+    }
+
+    pub inline fn slice_lower_bound(
+        direction: Direction,
+        comptime Key: type,
+        comptime Value: type,
+        comptime key_from_value: fn (*const Value) callconv(.@"inline") Key,
+        slice: []const Value,
+        key: Key,
+    ) []const Value {
+        maybe(slice.len == 0);
+        switch (direction) {
+            .ascending => {
+                const start = binary_search.binary_search_values_upsert_index(
+                    Key,
+                    Value,
+                    key_from_value,
+                    slice,
+                    key,
+                    .{ .mode = .lower_bound },
+                );
+
+                return if (start == slice.len) &.{} else slice[start..];
+            },
+            .descending => {
+                const end = end: {
+                    const index = binary_search.binary_search_values_upsert_index(
+                        Key,
+                        Value,
+                        key_from_value,
+                        slice,
+                        key,
+                        .{ .mode = .upper_bound },
+                    );
+                    break :end index + @intFromBool(
+                        index < slice.len and key_from_value(&slice[index]) <= key,
+                    );
+                };
+
+                return if (end == 0) &.{} else slice[0..end];
+            },
+        }
+    }
 };

data/ext/tb_client/tigerbeetle/src/lsm/scan_builder.zig

@@ -482,10 +482,10 @@ pub fn ScanType(
 
                     if (comptime is_composite_key(Value)) {
                         const prefix = prefix: {
-                            const prefix_min = Value.key_prefix(scan_impl.key_min);
-                            const prefix_max = Value.key_prefix(scan_impl.key_max);
-                            assert(prefix_min == prefix_max);
-                            break :prefix prefix_min;
+                            const prefix_lower = Value.key_prefix(scan_impl.key_lower);
+                            const prefix_upper = Value.key_prefix(scan_impl.key_upper);
+                            assert(prefix_lower == prefix_upper);
+                            break :prefix prefix_lower;
                         };
                         scan_impl.probe(Value.key_from_value(&.{
                             .field = prefix,
@@ -496,7 +496,7 @@ pub fn ScanType(
                         comptime assert(Groove.IdTree != void);
 
                         // Scans over the IdTree cannot probe for a next timestamp.
-                        assert(scan_impl.key_min == scan_impl.key_max);
+                        assert(scan_impl.key_lower == scan_impl.key_upper);
                     }
                 },
             }
@@ -516,12 +516,12 @@ pub fn ScanType(
                     if (comptime is_composite_key(Value)) {
                         // Secondary indexes can only produce results sorted by timestamp if
                         // scanning over the same key prefix.
-                        assert(Value.key_prefix(scan_impl.key_min) ==
-                            Value.key_prefix(scan_impl.key_max));
+                        assert(Value.key_prefix(scan_impl.key_lower) ==
+                            Value.key_prefix(scan_impl.key_upper));
                     } else {
                         comptime assert(tag == .id);
                         comptime assert(Groove.IdTree != void);
-                        assert(scan_impl.key_min == scan_impl.key_max);
+                        assert(scan_impl.key_lower == scan_impl.key_upper);
                     }
 
                     return scan_impl.direction;

data/ext/tb_client/tigerbeetle/src/lsm/scan_merge.zig

@@ -267,10 +267,7 @@ fn ScanMergeType(
                             // 2. k_way_merge₁ relays 11 to its streams (tree₁ + zig_zag_merge₂).
                             // 3. Probing zig_zag_merge₂ with 12 trips the assert, because tree₃ has
                             //    already produced a higher key (11 < 12).
-                            switch (self.direction) {
-                                .ascending => maybe(key_popped < timestamp),
-                                .descending => maybe(key_popped > timestamp),
-                            }
+                            maybe(self.direction.cmp(key_popped, .@"<", timestamp));
                         }
 
                         // Once the underlying streams have been changed, the merge iterator needs

data/ext/tb_client/tigerbeetle/src/lsm/scan_tree.zig

@@ -122,8 +122,8 @@ pub fn ScanTreeType(
         buffer: *const ScanBuffer,
 
         direction: Direction,
-        key_min: Key,
-        key_max: Key,
+        key_lower: Key,
+        key_upper: Key,
         snapshot: u64,
 
         table_mutable_values: []const Value,
@@ -207,8 +207,8 @@ pub fn ScanTreeType(
                 .buffer = buffer,
                 .state = .idle,
                 .snapshot = snapshot,
-                .key_min = key_min,
-                .key_max = key_max,
+                .key_lower = direction.lower(key_min, key_max),
+                .key_upper = direction.upper(key_min, key_max),
                 .direction = direction,
                 .table_mutable_values = table_mutable_values,
                 .table_immutable_values = table_immutable_values,
@@ -304,45 +304,35 @@ pub fn ScanTreeType(
             assert(self.state != .buffering);
 
             // No need to move if the current range is already tighter.
-            // It can abort scanning if the key is unreachable.
-            if (probe_key < self.key_min) {
-                if (self.direction == .descending) self.abort();
-                return;
-            } else if (self.key_max < probe_key) {
-                if (self.direction == .ascending) self.abort();
+            if (self.direction.cmp(probe_key, .@"<", self.key_lower)) return;
+            if (self.direction.cmp(self.key_upper, .@"<", probe_key)) {
+                self.abort(); // The key is unreachable, abort scanning.
                 return;
             }
 
             // It's allowed to probe multiple times with the same `probe_key`.
             // In this case, there's no need to move since the key range was already set.
-            if (switch (self.direction) {
-                .ascending => self.key_min == probe_key,
-                .descending => self.key_max == probe_key,
-            }) {
+            if (probe_key == self.key_lower) {
                 assert(self.state == .idle or
                     self.state == .seeking or
                     self.state == .needs_data);
                 return;
             }
 
-            // Updates the scan range depending on the direction.
-            switch (self.direction) {
-                .ascending => {
-                    assert(self.key_min < probe_key);
-                    assert(probe_key <= self.key_max);
-                    self.key_min = probe_key;
-                },
-                .descending => {
-                    assert(probe_key < self.key_max);
-                    assert(self.key_min <= probe_key);
-                    self.key_max = probe_key;
-                },
-            }
+            assert(self.direction.cmp(self.key_lower, .@"<", probe_key));
+            assert(self.direction.cmp(probe_key, .@"<=", self.key_upper));
+            self.key_lower = probe_key;
 
             // Re-slicing the in-memory tables:
             inline for (.{ &self.table_mutable_values, &self.table_immutable_values }) |field| {
                 const table_memory = field.*;
-                const slice: []const Value = probe_values(self.direction, table_memory, probe_key);
+                const slice: []const Value = self.direction.slice_lower_bound(
+                    Key,
+                    Value,
+                    key_from_value,
+                    table_memory,
+                    probe_key,
+                );
                 assert(slice.len <= table_memory.len);
                 field.* = slice;
             }
@@ -358,10 +348,7 @@ pub fn ScanTreeType(
                     // It's not expected to probe a scan that already produced a key equals
                     // or ahead the probe.
                     assert(self.merge_iterator.?.key_popped == null or
-                        switch (self.direction) {
-                            .ascending => self.merge_iterator.?.key_popped.? < probe_key,
-                            .descending => self.merge_iterator.?.key_popped.? > probe_key,
-                        });
+                        self.direction.cmp(self.merge_iterator.?.key_popped.?, .@"<", probe_key));
 
                     // Once the underlying streams have been changed, the merge iterator needs
                     // to reset its state, otherwise it may have dirty keys buffered.
@@ -429,12 +416,7 @@ pub fn ScanTreeType(
             assert(self.state == .seeking);
 
             if (values.len == 0) return null;
-
-            const value: *const Value = switch (self.direction) {
-                .ascending => &values[0],
-                .descending => &values[values.len - 1],
-            };
-
+            const value: *const Value = self.direction.slice_peek(values);
             const key = key_from_value(value);
             return key;
         }
@@ -452,25 +434,15 @@ pub fn ScanTreeType(
 
             assert(values.len > 0);
 
-            // TableMemory already deduplicates.
-            switch (self.direction) {
-                .ascending => {
-                    assert(values.len <= 1 or
-                        key_from_value(&values[0]) != key_from_value(&values[1]));
-
-                    const value_first = values[0];
-                    values = values[1..];
-                    return value_first;
-                },
-                .descending => {
-                    assert(values.len <= 1 or key_from_value(&values[values.len - 1]) !=
-                        key_from_value(&values[values.len - 2]));
+            const result, values = self.direction.slice_pop(values);
+            // TableMemory already deduplicates
+            if (values.len > 0) assert(self.direction.cmp(
+                key_from_value(&result),
+                .@"<",
+                key_from_value(self.direction.slice_peek(values)),
+            ));
 
-                    const value_last = values[values.len - 1];
-                    values = values[0 .. values.len - 1];
-                    return value_last;
-                },
-            }
+            return result;
         }
 
         fn merge_level_peek(self: *const ScanTree, level_index: u32) Pending!?Key {
@@ -488,40 +460,6 @@ pub fn ScanTreeType(
             const level = &self.levels[level_index];
             return level.pop();
         }
-
-        fn probe_values(direction: Direction, values: []const Value, key: Key) []const Value {
-            switch (direction) {
-                .ascending => {
-                    const start = binary_search.binary_search_values_upsert_index(
-                        Key,
-                        Value,
-                        key_from_value,
-                        values,
-                        key,
-                        .{ .mode = .lower_bound },
-                    );
-
-                    return if (start == values.len) &.{} else values[start..];
-                },
-                .descending => {
-                    const end = end: {
-                        const index = binary_search.binary_search_values_upsert_index(
-                            Key,
-                            Value,
-                            key_from_value,
-                            values,
-                            key,
-                            .{ .mode = .upper_bound },
-                        );
-                        break :end index + @intFromBool(
-                            index < values.len and key_from_value(&values[index]) <= key,
-                        );
-                    };
-
-                    return if (end == 0) &.{} else values[0..end];
-                },
-            }
-        }
     };
 }
 
@@ -655,11 +593,7 @@ fn ScanTreeLevelType(comptime ScanTree: type, comptime Storage: type) type {
                     assert(@intFromPtr(values.ptr) <=
                         @intFromPtr(self.buffer.value_block) + self.buffer.value_block.len);
 
-                    const value: *const Value = switch (self.scan.direction) {
-                        .ascending => &values[0],
-                        .descending => &values[values.len - 1],
-                    };
-
+                    const value: *const Value = self.scan.direction.slice_peek(values);
                     const key = key_from_value(value);
                     return key;
                 },
@@ -674,33 +608,19 @@ fn ScanTreeLevelType(comptime ScanTree: type, comptime Storage: type) type {
             assert(self.values == .buffered);
             assert(self.scan.state == .seeking);
 
-            var values = self.values.buffered;
+            const values = self.values.buffered;
             assert(values.len > 0);
             assert(@intFromPtr(values.ptr) >= @intFromPtr(self.buffer.value_block));
             assert(@intFromPtr(values.ptr) <=
                 @intFromPtr(self.buffer.value_block) + self.buffer.value_block.len);
 
-            defer {
-                assert(self.values == .buffered);
-                if (self.values.buffered.len == 0) {
-                    // Moving to the next `value_block` or `table_info`.
-                    // This will cause the next `peek()` to return `Pending`.
-                    self.move_next();
-                }
-            }
-
-            switch (self.scan.direction) {
-                .ascending => {
-                    const first_value = values[0];
-                    self.values = .{ .buffered = values[1..] };
-                    return first_value;
-                },
-                .descending => {
-                    const last_value = values[values.len - 1];
-                    self.values = .{ .buffered = values[0 .. values.len - 1] };
-                    return last_value;
-                },
+            const result, self.values.buffered = self.scan.direction.slice_pop(values);
+            if (self.values.buffered.len == 0) {
+                // Moving to the next `value_block` or `table_info`.
+                // This will cause the next `peek()` to return `Pending`.
+                self.move_next();
             }
+            return result;
         }
 
         pub fn probe(self: *ScanTreeLevel, probe_key: Key) void {
@@ -712,8 +632,10 @@ fn ScanTreeLevelType(comptime ScanTree: type, comptime Storage: type) type {
                 .fetching => {},
                 .buffered => |buffer| {
                     assert(buffer.len > 0);
-                    const slice: []const Value = ScanTree.probe_values(
-                        self.scan.direction,
+                    const slice: []const Value = self.scan.direction.slice_lower_bound(
+                        Key,
+                        Value,
+                        key_from_value,
                         buffer,
                         probe_key,
                     );
@@ -729,10 +651,7 @@ fn ScanTreeLevelType(comptime ScanTree: type, comptime Storage: type) type {
                         if (self.state == .iterating) {
                             const key_exclusive_next =
                                 self.state.iterating.key_exclusive_next;
-                            assert(switch (self.scan.direction) {
-                                .ascending => key_exclusive_next >= probe_key,
-                                .descending => key_exclusive_next <= probe_key,
-                            });
+                            assert(self.scan.direction.cmp(probe_key, .@"<=", key_exclusive_next));
                         }
 
                         self.values = .{ .buffered = slice };
@@ -772,10 +691,11 @@ fn ScanTreeLevelType(comptime ScanTree: type, comptime Storage: type) type {
                         // If the next key is out of the range,
                         // there are no more `table_info`s to scan next.
                         const key_exclusive_next = iterating.key_exclusive_next;
-                        if (switch (self.scan.direction) {
-                            .ascending => key_exclusive_next > self.scan.key_max,
-                            .descending => key_exclusive_next < self.scan.key_min,
-                        }) {
+                        if (self.scan.direction.cmp(
+                            self.scan.key_upper,
+                            .@"<",
+                            key_exclusive_next,
+                        )) {
                             // The next `table_info` is out of the key range, so it's finished.
                             self.state = .{ .finished = .{} };
                             self.values = .finished;
@@ -783,13 +703,14 @@ fn ScanTreeLevelType(comptime ScanTree: type, comptime Storage: type) type {
                             // Load the next `table_info`.
                             self.state = .loading_manifest;
                             self.values = .fetching;
-                            if (switch (self.scan.direction) {
-                                .ascending => key_exclusive_next < self.scan.key_min,
-                                .descending => key_exclusive_next > self.scan.key_max,
-                            }) {
+                            if (self.scan.direction.cmp(
+                                key_exclusive_next,
+                                .@"<",
+                                self.scan.key_lower,
+                            )) {
                                 // A probe() skipped past the last table we iterated, so our
                                 // key_exclusive_next is now out of bounds, superseded by the
-                                // tightened key_min (ascending) or key_max (descending) bound.
+                                // tightened lower bound.
                                 self.move_next_manifest_table(null);
                             } else {
                                 self.move_next_manifest_table(key_exclusive_next);
@@ -820,8 +741,8 @@ fn ScanTreeLevelType(comptime ScanTree: type, comptime Storage: type) type {
             if (manifest.next_table(.{
                 .level = self.level_index,
                 .snapshot = self.scan.snapshot,
-                .key_min = self.scan.key_min,
-                .key_max = self.scan.key_max,
+                .key_min = @min(self.scan.key_lower, self.scan.key_upper),
+                .key_max = @max(self.scan.key_lower, self.scan.key_upper),
                 .key_exclusive = key_exclusive,
                 .direction = self.scan.direction,
             })) |table_info| {
@@ -865,20 +786,23 @@ fn ScanTreeLevelType(comptime ScanTree: type, comptime Storage: type) type {
 
             const Range = struct { start: u32, end: u32 };
             const range_found: ?Range = range: {
+                const scan_key_min = @min(self.scan.key_lower, self.scan.key_upper);
+                const scan_key_max = @max(self.scan.key_lower, self.scan.key_upper);
+
                 const keys_max = Table.index_value_keys_used(self.buffer.index_block, .key_max);
                 const keys_min = Table.index_value_keys_used(self.buffer.index_block, .key_min);
                 // The `index_block` *might* contain the key range,
                 // otherwise, it shouldn't have been returned by the manifest.
                 assert(keys_min.len > 0 and keys_max.len > 0);
                 assert(keys_min.len == keys_max.len);
-                assert(keys_min[0] <= self.scan.key_max and
-                    self.scan.key_min <= keys_max[keys_max.len - 1]);
+                assert(keys_min[0] <= scan_key_max);
+                assert(scan_key_min <= keys_max[keys_max.len - 1]);
 
                 const indexes = binary_search.binary_search_keys_range_upsert_indexes(
                     Key,
                     keys_max,
-                    self.scan.key_min,
-                    self.scan.key_max,
+                    scan_key_min,
+                    scan_key_max,
                 );
 
                 // The key range was not found.
@@ -889,7 +813,7 @@ fn ScanTreeLevelType(comptime ScanTree: type, comptime Storage: type) type {
                 // the key depending on the `key_min`.
                 const end = end: {
                     break :end indexes.end + @intFromBool(
-                        indexes.end < keys_max.len and keys_min[indexes.end] <= self.scan.key_max,
+                        indexes.end < keys_max.len and keys_min[indexes.end] <= scan_key_max,
                     );
                 };
 
@@ -961,13 +885,15 @@ fn ScanTreeLevelType(comptime ScanTree: type, comptime Storage: type) type {
             assert(self.scan.state.buffering.pending_count > 0);
 
             const values = Table.value_block_values_used(value_block);
+            const scan_key_min = @min(self.scan.key_lower, self.scan.key_upper);
+            const scan_key_max = @max(self.scan.key_lower, self.scan.key_upper);
             const range = binary_search.binary_search_values_range(
                 Key,
                 Value,
                 key_from_value,
                 values,
-                self.scan.key_min,
-                self.scan.key_max,
+                scan_key_min,
+                scan_key_max,
             );
 
             if (range.count > 0) {
@@ -988,8 +914,8 @@ fn ScanTreeLevelType(comptime ScanTree: type, comptime Storage: type) type {
                 // otherwise, it shouldn't have been returned by the iterator.
                 const key_min = key_from_value(&values[0]);
                 const key_max = key_from_value(&values[values.len - 1]);
-                assert(key_min < self.scan.key_min and
-                    self.scan.key_max < key_max);
+                assert(key_min < scan_key_min);
+                assert(scan_key_max < key_max);
 
                 // Keep fetching if there are more value blocks on this table,
                 // or move to the next table otherwise.

data/ext/tb_client/tigerbeetle/src/lsm/table_value_iterator.zig

@@ -53,19 +53,16 @@ pub fn TableValueIteratorType(comptime Storage: type) type {
             assert(it.callback == null);
             assert(!it.empty());
 
-            const index: usize = switch (it.context.direction) {
-                .ascending => 0,
-                .descending => it.context.addresses.len - 1,
-            };
-
-            assert(it.context.checksums[index].padding == 0);
+            const address = it.context.direction.slice_peek(it.context.addresses).*;
+            const checksum = it.context.direction.slice_peek(it.context.checksums).*;
+            assert(checksum.padding == 0);
 
             it.callback = callback;
             it.context.grid.read_block(
                 .{ .from_local_or_global_storage = read_block_callback },
                 &it.read,
-                it.context.addresses[index],
-                it.context.checksums[index].value,
+                address,
+                checksum.value,
                 .{ .cache_read = true, .cache_write = true },
             );
         }
@@ -78,26 +75,14 @@ pub fn TableValueIteratorType(comptime Storage: type) type {
             const callback = it.callback.?;
             it.callback = null;
 
-            switch (it.context.direction) {
-                .ascending => {
-                    const header = schema.header_from_block(block);
-                    assert(header.address == it.context.addresses[0]);
-                    assert(header.checksum == it.context.checksums[0].value);
-
-                    it.context.addresses = it.context.addresses[1..];
-                    it.context.checksums = it.context.checksums[1..];
-                },
-                .descending => {
-                    const index_last = it.context.checksums.len - 1;
-                    const header = schema.header_from_block(block);
-                    assert(header.address == it.context.addresses[index_last]);
-                    assert(header.checksum == it.context.checksums[index_last].value);
-
-                    it.context.addresses = it.context.addresses[0..index_last];
-                    it.context.checksums = it.context.checksums[0..index_last];
-                },
-            }
+            const address, it.context.addresses =
+                it.context.direction.slice_pop(it.context.addresses);
+            const checksum, it.context.checksums =
+                it.context.direction.slice_pop(it.context.checksums);
 
+            const header = schema.header_from_block(block);
+            assert(header.address == address);
+            assert(header.checksum == checksum.value);
             assert(it.context.addresses.len == it.context.checksums.len);
             callback(it, block);
         }

data/ext/tb_client/tigerbeetle/src/lsm/zig_zag_merge.zig

@@ -74,12 +74,8 @@ pub fn ZigZagMergeIteratorType(
                 return null;
 
             if (it.key_popped) |previous| {
-                switch (std.math.order(previous, key)) {
-                    .lt => assert(it.direction == .ascending),
-                    // Duplicate values are not expected.
-                    .eq => unreachable,
-                    .gt => assert(it.direction == .descending),
-                }
+                // Duplicate values are not expected.
+                assert(it.direction.cmp(previous, .@"<", key));
             }
             it.key_popped = key;
 
@@ -134,19 +130,13 @@ pub fn ZigZagMergeIteratorType(
                         return null;
 
                     // The stream cannot regress.
-                    assert(
-                        it.probe_key_previous == null or
-                            key == it.probe_key_previous.? or
-                            it.key_ahead(.{
-                                .key_after = key,
-                                .key_before = it.probe_key_previous.?,
-                            }),
-                    );
+                    assert(it.probe_key_previous == null or
+                        it.direction.cmp(it.probe_key_previous.?, .@"<=", key));
 
                     // The keys match, continuing to the next stream.
-                    if (key == probe_key) continue;
+                    if (probe_key == key) continue;
 
-                    if (it.key_ahead(.{ .key_after = key, .key_before = probe_key })) {
+                    if (it.direction.cmp(probe_key, .@"<", key)) {
                         // The stream is ahead, it will be the probe key,
                         // meaning all streams before must be probed.
                         probe_key = key;
@@ -180,7 +170,7 @@ pub fn ZigZagMergeIteratorType(
                     if (key == probe_key) {
                         probing.unset(stream_index);
                     } else {
-                        assert(it.key_ahead(.{ .key_after = key, .key_before = probe_key }));
+                        assert(it.direction.cmp(probe_key, .@"<", key));
                     }
                 }
             }
@@ -207,24 +197,11 @@ pub fn ZigZagMergeIteratorType(
 
             // The iterator cannot regress.
             assert(it.probe_key_previous == null or
-                probe_key == it.probe_key_previous.? or
-                it.key_ahead(.{ .key_after = probe_key, .key_before = it.probe_key_previous.? }));
+                it.direction.cmp(it.probe_key_previous.?, .@"<=", probe_key));
 
             it.probe_key_previous = probe_key;
             return if (pending.count() == 0) probe_key else error.Pending;
         }
-
-        /// Returns true if `key_after` is ahead of `key_before` depending on the direction,
-        /// that is `key_after > key_before` (ascending) or `key_after < key_before` (descending).
-        inline fn key_ahead(
-            it: *const ZigZagMergeIterator,
-            keys: struct { key_after: Key, key_before: Key },
-        ) bool {
-            return switch (it.direction) {
-                .ascending => keys.key_after > keys.key_before,
-                .descending => keys.key_after < keys.key_before,
-            };
-        }
     };
 }
 

data/ext/tb_client/tigerbeetle/src/vsr/replica_test.zig

@@ -476,6 +476,24 @@ test "Cluster: network: partition 1-2 (isolate primary, asymmetric, receive-only
     try c.request(2, 2);
 }
 
+test "Cluster: network: partition primary-all (isolate primary, asymmetric, send-only)" {
+    // The primary can send to the backups and clients, but not receive.
+    // Since primary can't see requests, it doesn't know that it needs to abdicate.
+    // The rest of the cluster needs to view-change anyway.
+    const t = try TestContext.init(.{ .replica_count = 3 });
+    defer t.deinit();
+
+    var c = t.clients(.{});
+    try c.request(1, 1);
+    t.replica(.A0).drop(.__, .incoming, .request);
+    // Since the primary doesn't receive requests, it can't ever abdicate.
+    const mark = marks.check("send_commit: primary abdicating");
+    // TODO:
+    // try c.request(2, 2);
+    try c.request(2, 1);
+    try mark.expect_not_hit();
+}
+
 test "Cluster: network: partition client-primary (symmetric)" {
     // Clients cannot communicate with the primary, but they still request/reply via a backup.
     const t = try TestContext.init(.{ .replica_count = 3 });

data/lib/tigerbeetle/version.rb

@@ -1,4 +1,4 @@
 module TigerBeetle
-  VERSION = '0.0.37'.freeze
-  TB_VERSION = '0.16.73'.freeze
+  VERSION = '0.0.38'.freeze
+  TB_VERSION = '0.16.74'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tigerbeetle
 version: !ruby/object:Gem::Version
-  version: 0.0.37
+  version: 0.0.38
 platform: ruby
 authors:
 - Anthony D
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-08 00:00:00.000000000 Z
+date: 2026-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi