tiny.sql.Write

1pub const Write = struct {2    store: *Store,3    snapshot_generation: u64,4    mutations: std.ArrayList(Mutation) = .empty,5    closed: bool = false,67    pub fn deinit(self: *Write) void {8        for (self.mutations.items) |*mutation| mutation.deinit(self.store.allocator);9        self.mutations.deinit(self.store.allocator);10        self.closed = true;11    }1213    pub fn get(self: *const Write, key: []const u8) Error!?[]const u8 {14        if (self.closed) return error.TransactionClosed;15        if (self.localMutation(key)) |mutation| {16            if (mutation.deleted) return null;17            return mutation.value;18        }19        return self.store.getAt(key, self.snapshot_generation);20    }2122    pub fn put(self: *Write, key: []const u8, value: []const u8) Error!void {23        if (self.closed) return error.TransactionClosed;24        const phase = trace.scope("write.put");25        defer phase.end();26        try self.setMutation(key, value, false);27    }2829    pub fn delete(self: *Write, key: []const u8) Error!void {30        if (self.closed) return error.TransactionClosed;31        const phase = trace.scope("write.delete");32        defer phase.end();33        try self.setMutation(key, &.{}, true);34    }3536    pub fn commit(self: *Write) Error!u64 {37        if (self.closed) return error.TransactionClosed;38        const phase = trace.scope("write.commit");39        defer phase.end();40        if (self.mutations.items.len == 0) {41            self.closed = true;42            return self.store.generation;43        }4445        for (self.mutations.items) |mutation| {46            if (latestGenerationForKey(self.store, mutation.key)) |generation| {47                if (generation > self.snapshot_generation) return error.TransactionConflict;48            }49        }5051        const next_generation = self.store.generation + 1;52        try self.store.versions.ensureTotalCapacity(self.store.allocator, self.store.versions.items.len + self.mutations.items.len);53        for (self.mutations.items) |mutation| {54            const insert_index = lowerBoundVersion(self.store.versions.items, mutation.key, next_generation);55            self.store.versions.insertAssumeCapacity(insert_index, .{56                .key = mutation.key,57                .value = mutation.value,58                .generation = next_generation,59                .deleted = mutation.deleted,60            });61        }62        std.debug.assert(versionsAreOrdered(self.store.versions.items));63        self.store.generation = next_generation;64        self.mutations.clearRetainingCapacity();65        self.closed = true;66        trace.progress("write.commit.complete");67        return next_generation;68    }6970    fn setMutation(self: *Write, key: []const u8, value: []const u8, deleted: bool) Error!void {71        if (self.localMutationIndex(key)) |index| {72            var mutation = &self.mutations.items[index];73            if (!mutation.deleted) freeOwned(self.store.allocator, mutation.value);74            mutation.value = &.{};75            if (!deleted) mutation.value = try self.store.allocator.dupe(u8, value);76            mutation.deleted = deleted;77            return;78        }7980        const owned_key = try self.store.allocator.dupe(u8, key);81        errdefer freeOwned(self.store.allocator, owned_key);82        var owned_value: []u8 = &.{};83        if (!deleted) owned_value = try self.store.allocator.dupe(u8, value);84        errdefer if (!deleted) freeOwned(self.store.allocator, owned_value);85        try self.mutations.append(self.store.allocator, .{86            .key = owned_key,87            .value = owned_value,88            .deleted = deleted,89        });90        std.mem.sort(Mutation, self.mutations.items, {}, mutationLessThan);91    }9293    fn localMutation(self: *const Write, key: []const u8) ?Mutation {94        if (self.localMutationIndex(key)) |index| return self.mutations.items[index];95        return null;96    }9798    fn localMutationIndex(self: *const Write, key: []const u8) ?usize {99        var low: usize = 0;100        var high = self.mutations.items.len;101        while (low < high) {102            const mid = low + (high - low) / 2;103            switch (simd.order(Bytes, self.mutations.items[mid].key, key)) {104                .lt => low = mid + 1,105                .eq => return mid,106                .gt => high = mid,107            }108        }109        return null;110    }111};

1pub const Write = store.Write;