tigerbeetle 0.0.36 → 0.0.38

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

@@ -0,0 +1,390 @@
+const std = @import("std");
+const assert = std.debug.assert;
+
+const constants = @import("./constants.zig");
+
+const QueueLink = extern struct {
+    next: ?*QueueLink = null,
+};
+
+/// An intrusive first in/first out linked list.
+/// The element type T must have a field called "link" of type QueueType(T).Link.
+pub fn QueueType(comptime T: type) type {
+    return struct {
+        any: QueueAny,
+
+        pub const Link = QueueLink;
+        const Queue = @This();
+
+        pub inline fn init(options: struct {
+            name: ?[]const u8,
+            verify_push: bool = true,
+        }) Queue {
+            return .{ .any = .{
+                .name = options.name,
+                .verify_push = options.verify_push,
+            } };
+        }
+
+        pub inline fn push(self: *Queue, link: *T) void {
+            self.any.push(&link.link);
+        }
+
+        pub inline fn pop(self: *Queue) ?*T {
+            const link = self.any.pop() orelse return null;
+            return @alignCast(@fieldParentPtr("link", link));
+        }
+
+        pub inline fn peek_last(self: *const Queue) ?*T {
+            const link = self.any.peek_last() orelse return null;
+            return @alignCast(@fieldParentPtr("link", link));
+        }
+
+        pub inline fn peek(self: *const Queue) ?*T {
+            const link = self.any.peek() orelse return null;
+            return @alignCast(@fieldParentPtr("link", link));
+        }
+
+        pub fn count(self: *const Queue) u64 {
+            return self.any.count;
+        }
+
+        pub inline fn empty(self: *const Queue) bool {
+            return self.any.empty();
+        }
+
+        /// Returns whether the linked list contains the given *exact element* (pointer comparison).
+        pub inline fn contains(self: *const Queue, elem_needle: *const T) bool {
+            return self.any.contains(&elem_needle.link);
+        }
+
+        /// Remove an element from the Queue. Asserts that the element is
+        /// in the Queue. This operation is O(N), if this is done often you
+        /// probably want a different data structure.
+        pub inline fn remove(self: *Queue, to_remove: *T) void {
+            self.any.remove(&to_remove.link);
+        }
+
+        pub inline fn reset(self: *Queue) void {
+            self.any.reset();
+        }
+
+        pub inline fn iterate(self: *const Queue) Iterator {
+            return .{ .any = self.any.iterate() };
+        }
+
+        pub const Iterator = struct {
+            any: QueueAny.Iterator,
+
+            pub inline fn next(iterator: *@This()) ?*T {
+                const link = iterator.any.next() orelse return null;
+                return @alignCast(@fieldParentPtr("link", link));
+            }
+        };
+    };
+}
+
+// Non-generic implementation for smaller binary and faster compile times.
+const QueueAny = struct {
+    in: ?*QueueLink = null,
+    out: ?*QueueLink = null,
+    count: u64 = 0,
+
+    // This should only be null if you're sure we'll never want to monitor `count`.
+    name: ?[]const u8,
+
+    // If the number of elements is large, the constants.verify check in push() can be too
+    // expensive. Allow the user to gate it. Could also be a comptime param?
+    verify_push: bool = true,
+
+    pub fn push(self: *QueueAny, link: *QueueLink) void {
+        if (constants.verify and self.verify_push) assert(!self.contains(link));
+
+        assert(link.next == null);
+        if (self.in) |in| {
+            in.next = link;
+            self.in = link;
+        } else {
+            assert(self.out == null);
+            self.in = link;
+            self.out = link;
+        }
+        self.count += 1;
+    }
+
+    pub fn pop(self: *QueueAny) ?*QueueLink {
+        const result = self.out orelse return null;
+        self.out = result.next;
+        result.next = null;
+        if (self.in == result) self.in = null;
+        self.count -= 1;
+        return result;
+    }
+
+    pub fn peek_last(self: *const QueueAny) ?*QueueLink {
+        return self.in;
+    }
+
+    pub fn peek(self: *const QueueAny) ?*QueueLink {
+        return self.out;
+    }
+
+    pub fn empty(self: *const QueueAny) bool {
+        return self.peek() == null;
+    }
+
+    pub fn contains(self: *const QueueAny, needle: *const QueueLink) bool {
+        var iterator = self.peek();
+        while (iterator) |link| : (iterator = link.next) {
+            if (link == needle) return true;
+        }
+        return false;
+    }
+
+    pub fn remove(self: *QueueAny, to_remove: *QueueLink) void {
+        if (to_remove == self.out) {
+            _ = self.pop();
+            return;
+        }
+        var it = self.out;
+        while (it) |link| : (it = link.next) {
+            if (to_remove == link.next) {
+                if (to_remove == self.in) self.in = link;
+                link.next = to_remove.next;
+                to_remove.next = null;
+                self.count -= 1;
+                break;
+            }
+        } else unreachable;
+    }
+
+    pub fn reset(self: *QueueAny) void {
+        self.* = .{
+            .name = self.name,
+            .verify_push = self.verify_push,
+        };
+    }
+
+    pub fn iterate(self: *const QueueAny) Iterator {
+        return .{
+            .head = self.out,
+        };
+    }
+
+    const Iterator = struct {
+        head: ?*QueueLink,
+
+        fn next(iterator: *Iterator) ?*QueueLink {
+            const head = iterator.head orelse return null;
+            iterator.head = head.next;
+            return head;
+        }
+    };
+};
+
+test "Queue: push/pop/peek/remove/empty" {
+    const testing = @import("std").testing;
+
+    const Item = struct { link: QueueType(@This()).Link = .{} };
+
+    var one: Item = .{};
+    var two: Item = .{};
+    var three: Item = .{};
+
+    var fifo = QueueType(Item).init(.{
+        .name = null,
+        .verify_push = true,
+    });
+    try testing.expect(fifo.empty());
+
+    fifo.push(&one);
+    try testing.expect(!fifo.empty());
+    try testing.expectEqual(@as(?*Item, &one), fifo.peek());
+    try testing.expect(fifo.contains(&one));
+    try testing.expect(!fifo.contains(&two));
+    try testing.expect(!fifo.contains(&three));
+
+    fifo.push(&two);
+    fifo.push(&three);
+    try testing.expect(!fifo.empty());
+    try testing.expectEqual(@as(?*Item, &one), fifo.peek());
+    try testing.expect(fifo.contains(&one));
+    try testing.expect(fifo.contains(&two));
+    try testing.expect(fifo.contains(&three));
+
+    fifo.remove(&one);
+    try testing.expect(!fifo.empty());
+    try testing.expectEqual(@as(?*Item, &two), fifo.pop());
+    try testing.expectEqual(@as(?*Item, &three), fifo.pop());
+    try testing.expectEqual(@as(?*Item, null), fifo.pop());
+    try testing.expect(fifo.empty());
+    try testing.expect(!fifo.contains(&one));
+    try testing.expect(!fifo.contains(&two));
+    try testing.expect(!fifo.contains(&three));
+
+    fifo.push(&one);
+    fifo.push(&two);
+    fifo.push(&three);
+    fifo.remove(&two);
+    try testing.expect(!fifo.empty());
+    try testing.expectEqual(@as(?*Item, &one), fifo.pop());
+    try testing.expectEqual(@as(?*Item, &three), fifo.pop());
+    try testing.expectEqual(@as(?*Item, null), fifo.pop());
+    try testing.expect(fifo.empty());
+
+    fifo.push(&one);
+    fifo.push(&two);
+    fifo.push(&three);
+    fifo.remove(&three);
+    try testing.expect(!fifo.empty());
+    try testing.expectEqual(@as(?*Item, &one), fifo.pop());
+    try testing.expect(!fifo.empty());
+    try testing.expectEqual(@as(?*Item, &two), fifo.pop());
+    try testing.expect(fifo.empty());
+    try testing.expectEqual(@as(?*Item, null), fifo.pop());
+    try testing.expect(fifo.empty());
+
+    fifo.push(&one);
+    fifo.push(&two);
+    fifo.remove(&two);
+    fifo.push(&three);
+    try testing.expectEqual(@as(?*Item, &one), fifo.pop());
+    try testing.expectEqual(@as(?*Item, &three), fifo.pop());
+    try testing.expectEqual(@as(?*Item, null), fifo.pop());
+    try testing.expect(fifo.empty());
+}
+
+test "Queue: fuzz" {
+    const stdx = @import("stdx");
+    const fuzz = @import("./testing/fuzz.zig");
+
+    const Item = struct {
+        value: u64,
+        link: QueueType(@This()).Link,
+    };
+    const Queue = QueueType(Item);
+    const Model = stdx.RingBufferType(u64, .slice);
+
+    const gpa = std.testing.allocator;
+    var prng = stdx.PRNG.from_seed_testing();
+
+    for (0..100) |_| {
+        const N = 1000;
+
+        var queue = Queue.init(.{
+            .name = "fuzz",
+        });
+        var model = try Model.init(gpa, N);
+        defer model.deinit(gpa);
+
+        // Implement "remove" by copy.
+        var model_scratch = try Model.init(gpa, N);
+        defer model_scratch.deinit(gpa);
+
+        var items = try gpa.alloc(Item, N);
+        defer gpa.free(items);
+
+        for (items, 0..) |*item, value| {
+            item.* = .{ .value = value, .link = .{} };
+        }
+
+        var free: std.ArrayListUnmanaged(usize) = .{};
+        defer free.deinit(gpa);
+
+        try free.ensureTotalCapacity(gpa, N);
+        for (items, 0..) |_, index| {
+            free.appendAssumeCapacity(index);
+        }
+
+        const Declarations = fuzz.DeclEnumExcludingType(
+            Queue,
+            &.{ .Link, .Iterator, .init, .count, .empty },
+        );
+        const weights = fuzz.random_enum_weights(&prng, Declarations);
+
+        for (0..N) |_| {
+            switch (prng.enum_weighted(Declarations, weights)) {
+                .push => {
+                    if (free.items.len > 0) {
+                        const index = free.swapRemove(prng.index(free.items));
+                        model.push_assume_capacity(items[index].value);
+                        queue.push(&items[index]);
+                    }
+                },
+                .pop => {
+                    if (model.empty()) {
+                        assert(queue.pop() == null);
+                    } else {
+                        const item = queue.pop().?;
+                        assert(item.value == model.pop().?);
+
+                        const index = @divExact(
+                            (@intFromPtr(item) - @intFromPtr(items.ptr)),
+                            @sizeOf(Item),
+                        );
+                        free.appendAssumeCapacity(index);
+                    }
+                },
+                .peek => {
+                    if (model.head()) |head| {
+                        assert(queue.peek().?.value == head);
+                    } else {
+                        assert(queue.peek() == null);
+                    }
+                },
+                .peek_last => {
+                    if (model.tail()) |tail| {
+                        assert(queue.peek_last().?.value == tail);
+                    } else {
+                        assert(queue.peek_last() == null);
+                    }
+                },
+                .contains => {
+                    const item = &items[prng.index(items)];
+
+                    const model_contains = model_contains: {
+                        var it = model.iterator();
+                        while (it.next()) |v| {
+                            if (v == item.value) {
+                                break :model_contains true;
+                            }
+                        }
+                        break :model_contains false;
+                    };
+                    assert(model_contains == queue.contains(item));
+                },
+                .remove => {
+                    const item = &items[prng.index(items)];
+                    if (queue.contains(item)) {
+                        queue.remove(item);
+
+                        assert(model_scratch.empty());
+                        while (model.pop()) |value| {
+                            if (value != item.value) {
+                                model_scratch.push_assume_capacity(value);
+                            }
+                        }
+                        std.mem.swap(Model, &model, &model_scratch);
+                    }
+                },
+                .reset => {
+                    model.clear();
+                    queue.reset();
+                },
+                .iterate => {
+                    var queue_iterator = queue.iterate();
+                    var model_iterator = model.iterator();
+
+                    while (queue_iterator.next()) |queue_item| {
+                        const model_item = model_iterator.next().?;
+                        assert(queue_item.value == model_item);
+                    }
+                    assert(model_iterator.next() == null);
+                    assert(queue_iterator.next() == null);
+                },
+            }
+            assert(queue.count() == model.count);
+            assert(queue.empty() == model.empty());
+        }
+    }
+}

data/ext/tb_client/tigerbeetle/src/repl/completion.zig

@@ -0,0 +1,201 @@
+const std = @import("std");
+const stdx = @import("stdx");
+const assert = std.debug.assert;
+
+const RingBuffer = stdx.RingBufferType;
+const BoundedArray = stdx.BoundedArrayType;
+
+const keywords = [_][]const u8{
+    "create_accounts",
+    "create_transfers",
+    "lookup_accounts",
+    "lookup_transfers",
+    "get_account_transfers",
+    "get_account_balances",
+    "query_accounts",
+    "query_transfers",
+    "help",
+    "id",
+    "code",
+    "ledger",
+    "flags",
+    "account_id",
+    "debit_account_id",
+    "credit_account_id",
+    "amount",
+};
+const completion_entries = keywords.len;
+const completion_entry_bytes = 512;
+
+pub const Completion = struct {
+    const CompletionList = RingBuffer([completion_entry_bytes]u8, .{ .array = completion_entries });
+
+    matches: CompletionList,
+    prefix: BoundedArray(u8, completion_entry_bytes),
+    suffix: BoundedArray(u8, completion_entry_bytes),
+    query: BoundedArray(u8, completion_entry_bytes),
+    match_index: usize = 0,
+
+    pub fn init(self: *Completion) !void {
+        self.* = Completion{
+            .matches = CompletionList.init(),
+            .prefix = BoundedArray(u8, completion_entry_bytes){},
+            .suffix = BoundedArray(u8, completion_entry_bytes){},
+            .query = BoundedArray(u8, completion_entry_bytes){},
+        };
+    }
+
+    // Split the buffer into 3 parts -
+    // prefix: Everything before the word being completed.
+    // query : Partial word that needs completion, from last whitespace to buffer index.
+    // suffix: Everything after the cursor position.
+
+    /// Split the input buffer into prefix, query and suffix. Then tries to find the completions
+    /// matching the current query.
+    pub fn split_and_complete(self: *Completion, buffer: []const u8, buffer_index: usize) !void {
+        var query_start_index = buffer_index;
+
+        while (query_start_index > 0 and !std.ascii.isWhitespace(buffer[query_start_index - 1])) {
+            query_start_index -= 1;
+        }
+
+        self.prefix.clear();
+        self.prefix.push_slice(buffer[0..query_start_index]);
+
+        self.suffix.clear();
+        self.suffix.push_slice(buffer[buffer_index..]);
+
+        if (self.matches.count == 0) {
+            self.query.clear();
+            self.query.push_slice(buffer[query_start_index..buffer_index]);
+
+            try self.get_completions(self.query.const_slice());
+        }
+    }
+
+    /// Returns the next match in the completion list. If the completion list is empty,
+    /// returns the query.
+    pub fn get_next_completion(self: *Completion) ![]const u8 {
+        if (self.matches.count > 0) {
+            const match_ptr = self.matches.get_ptr(self.match_index).?;
+            self.match_index = (self.match_index + 1) % self.matches.count;
+            return std.mem.sliceTo(match_ptr, '\x00');
+        } else {
+            return self.query.const_slice();
+        }
+    }
+
+    /// Reset the completion list.
+    pub fn clear(self: *Completion) void {
+        self.matches.clear();
+        self.prefix.clear();
+        self.suffix.clear();
+        self.query.clear();
+        self.match_index = 0;
+    }
+
+    /// Returns number of items in the completion list.
+    pub fn count(self: *Completion) usize {
+        return self.matches.count;
+    }
+
+    fn get_completions(self: *Completion, target: []const u8) !void {
+        if (std.mem.eql(u8, target, "")) {
+            return;
+        }
+
+        for (keywords) |kw| {
+            if (std.mem.startsWith(u8, kw, target)) {
+                assert(kw.len < completion_entry_bytes - 1);
+
+                if (self.matches.full()) {
+                    self.matches.advance_head();
+                }
+
+                const completion_tail = self.matches.next_tail_ptr().?;
+                stdx.copy_left(.exact, u8, completion_tail[0..kw.len], kw);
+                completion_tail[kw.len] = '\x00';
+                self.matches.advance_tail();
+            }
+        }
+    }
+};
+
+test "completion.zig: Split buffer and complete" {
+    const tests = [_]struct {
+        buffer: []const u8,
+        idx: usize,
+        prefix: BoundedArray(u8, completion_entry_bytes),
+        suffix: BoundedArray(u8, completion_entry_bytes),
+        query: BoundedArray(u8, completion_entry_bytes),
+        matches: BoundedArray([]const u8, 5),
+    }{
+        .{
+            .buffer = "",
+            .idx = 0,
+            .prefix = try BoundedArray(u8, completion_entry_bytes).from_slice(""),
+            .suffix = try BoundedArray(u8, completion_entry_bytes).from_slice(""),
+            .query = try BoundedArray(u8, completion_entry_bytes).from_slice(""),
+            .matches = try BoundedArray([]const u8, 5).from_slice(&.{}),
+        },
+        .{
+            .buffer = "creat",
+            .idx = 5,
+            .prefix = try BoundedArray(u8, completion_entry_bytes).from_slice(""),
+            .suffix = try BoundedArray(u8, completion_entry_bytes).from_slice(""),
+            .query = try BoundedArray(u8, completion_entry_bytes).from_slice("creat"),
+            .matches = try BoundedArray([]const u8, 5).from_slice(
+                &.{ "create_accounts", "create_transfers" },
+            ),
+        },
+        .{
+            .buffer = "create_accounts id=1 co",
+            .idx = 23,
+            .prefix = try BoundedArray(u8, completion_entry_bytes).from_slice(
+                "create_accounts id=1 ",
+            ),
+            .suffix = try BoundedArray(u8, completion_entry_bytes).from_slice(""),
+            .query = try BoundedArray(u8, completion_entry_bytes).from_slice("co"),
+            .matches = try BoundedArray([]const u8, 5).from_slice(&.{"code"}),
+        },
+        .{
+            .buffer = "create_accounts id=1 co ledger=700",
+            .idx = 23,
+            .prefix = try BoundedArray(u8, completion_entry_bytes).from_slice(
+                "create_accounts id=1 ",
+            ),
+            .suffix = try BoundedArray(u8, completion_entry_bytes).from_slice(" ledger=700"),
+            .query = try BoundedArray(u8, completion_entry_bytes).from_slice("co"),
+            .matches = try BoundedArray([]const u8, 5).from_slice(&.{"code"}),
+        },
+    };
+
+    for (tests) |t| {
+        var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+        defer arena.deinit();
+
+        var completion: Completion = undefined;
+        try completion.init();
+        var c = &completion;
+
+        try c.split_and_complete(t.buffer, t.idx);
+
+        try std.testing.expectEqualSlices(u8, c.prefix.const_slice(), t.prefix.const_slice());
+        try std.testing.expectEqualSlices(u8, c.suffix.const_slice(), t.suffix.const_slice());
+        try std.testing.expectEqualSlices(u8, c.query.const_slice(), c.query.const_slice());
+        try std.testing.expectEqual(c.count(), t.matches.count());
+
+        var i: usize = 0;
+        while (i < t.matches.count()) {
+            const cur_match = try c.get_next_completion();
+            try std.testing.expectEqualSlices(u8, cur_match, t.matches.get(i));
+            i += 1;
+        }
+
+        c.clear();
+        try std.testing.expectEqual(@as(usize, 0), c.count());
+        try std.testing.expectEqual(@as(usize, 0), c.prefix.count());
+        try std.testing.expectEqual(@as(usize, 0), c.suffix.count());
+        try std.testing.expectEqual(@as(usize, 0), c.query.count());
+    }
+}