tiny.sql.history

1pub const ChunkSpan = struct {2    first: i64,3    last: i64,4};

1pub const PackRecordKind = enum(u32) {2    row_chunk = 1,3    chunk_index_page = 2,4    tree_node = 3,5    relation_rows = 4,6    relation_root = 5,7    database_root = 6,8    conflict = 7,9    conflict_root = 8,10};

1pub const DatabaseRootView = struct {2    conflicts: version.Hash,3    entries: []const version.RelationEntry,4};

1pub const FastForwardDecision = enum {2    pending,3    baseline,4    target,5};

1pub const FastForwardRecovery = struct {2    id: version.Hash,3    name: []const u8,4    expected: version.Hash,5    target: version.Hash,6    decision: FastForwardDecision = .pending,7};

1pub const FastForwardUpdate = struct {2    history: *History,3    id: version.Hash,45    pub fn commit(self: *FastForwardUpdate) Error!void {6        try self.history.decideFastForward(self.id, .target);7    }89    pub fn abort(self: *FastForwardUpdate) Error!void {10        try self.history.decideFastForward(self.id, .baseline);11    }1213    pub fn complete(self: *FastForwardUpdate) Error!void {14        try self.history.completeFastForward(self.id);15    }16};

1pub const IncrementalBase = struct {2    root: version.Hash,3    edited: []const i64,4};

1pub const RelationKeysView = struct {2    allocator: Allocator,3    owned: ?[]?version.Hash = null,4    table_key: ?version.Hash,5    index_keys: []const ?version.Hash,67    pub fn deinit(self: *RelationKeysView) void {8        if (self.owned) |owned| self.allocator.free(owned);9        self.* = undefined;10    }11};

1pub const RelationRowsWriter = struct {2    history: *History,3    root: version.Hash,4    boundary: ?i64,5    previous: ?i64 = null,6    chunker: chunk_mod.Chunker = .{},7    chunks: std.ArrayList(version.Hash) = .empty,8    spans: std.ArrayList(record_mod.ChunkSpan) = .empty,9    finished: bool = false,1011    pub fn append(self: *RelationRowsWriter, rowid: i64, bytes: []const u8) Error!void {12        std.debug.assert(!self.finished);13        if (self.boundary) |boundary| {14            if (rowid <= boundary) return error.InvalidHistory;15        }16        if (self.previous) |previous| {17            if (rowid <= previous) return error.InvalidHistory;18        }19        self.previous = rowid;20        if (try self.chunker.append(self.history.allocator, rowid, bytes)) try self.emit();21    }2223    pub fn finish(self: *RelationRowsWriter) Error!void {24        std.debug.assert(!self.finished);25        if (self.chunker.pending() != 0) try self.emit();26        try self.history.finishRelationRows(self.root, self.chunks.items, self.spans.items);27        self.finished = true;28    }2930    pub fn deinit(self: *RelationRowsWriter) void {31        const allocator = self.history.allocator;32        self.chunker.deinit(allocator);33        self.chunks.deinit(allocator);34        self.spans.deinit(allocator);35        self.* = undefined;36    }3738    fn emit(self: *RelationRowsWriter) Error!void {39        var rows_scratch: [chunk_mod.max_rows]version.RelationRow = undefined;40        const rows = self.chunker.view(&rows_scratch);41        std.debug.assert(rows.len > 0);42        const digest = chunk_mod.digest(rows);43        const allocator = self.history.allocator;44        try self.chunks.ensureUnusedCapacity(allocator, 1);45        try self.spans.ensureUnusedCapacity(allocator, 1);46        try self.history.putRowChunk(digest, rows);47        self.chunks.appendAssumeCapacity(digest);48        self.spans.appendAssumeCapacity(.{ .first = rows[0].rowid, .last = rows[rows.len - 1].rowid });49        self.chunker.reset();50    }51};

1pub const WriteBatch = struct {2    history: *History,3    active: bool = true,45    pub fn finish(self: *WriteBatch) Error!void {6        if (!self.active) return;7        try self.history.ensureUsable();8        std.debug.assert(self.history.write_batch_depth > 0);9        if (self.history.write_batch_depth > 1) {10            self.history.write_batch_depth -= 1;11            self.active = false;12            return;13        }14        try self.history.flushPendingWrite();15        self.history.write_batch_depth = 0;16        errdefer self.history.write_batch_depth = 1;17        try self.history.flushSync();18        self.active = false;19    }2021    pub fn deinit(self: *WriteBatch) void {22        if (!self.active) return;23        std.debug.assert(self.history.write_batch_depth > 0);24        self.history.write_batch_depth -= 1;25        self.active = false;26    }27};

1pub const Error = Allocator.Error || branch.Error || std.Io.File.OpenError || std.Io.File.StatError || std.Io.File.ReadPositionalError || std.Io.File.WritePositionalError || std.Io.File.SetLengthError || std.Io.File.SyncError || std.Io.Dir.ReadFileAllocError || error{2    Interrupted,3    InvalidHistory,4    TruncatedHistory,5    HistoryNotFound,6    DatabaseRootNotFound,7    RelationRootNotFound,8    RelationRowsNotFound,9    RefExists,10    RefNotFound,11    RefChanged,12    RecoveryRequired,13    ReadOnly,14    ConflictRootNotFound,15    ConflictArtifactNotFound,16};

1pub fn freeRefList(allocator: Allocator, refs: []version.Ref) void {2    for (refs) |ref_value| allocator.free(ref_value.name);3    if (refs.len != 0) allocator.free(refs);4}

1const record_mod = @import("record.zig");2const conflict_mod = @import("conflict.zig");3const refs_mod = @import("refs.zig");4const store_mod = @import("store.zig");5pub const identity = @import("identity.zig");6pub const resolver = @import("resolver.zig");7pub const verification = @import("verify.zig");89pub const segment = @import("segment/root.zig");10pub const instrumentation = @import("instrumentation.zig");1112pub const PackRecordKind = record_mod.PackRecordKind;13pub const ChunkSpan = record_mod.ChunkSpan;14pub const ConflictEntries = conflict_mod.ConflictEntries;15pub const ConflictArtifacts = conflict_mod.ConflictArtifacts;16pub const Error = store_mod.Error;17pub const Options = store_mod.Options;18pub const RecoveryPolicy = store_mod.RecoveryPolicy;19pub const Recovery = store_mod.Recovery;20pub const Truncation = store_mod.Truncation;21pub const freeRefList = store_mod.freeRefList;22pub const DatabaseRootView = store_mod.DatabaseRootView;23pub const RelationKeysView = store_mod.RelationKeysView;24pub const History = store_mod.History;25pub const RelationRowsWriter = store_mod.RelationRowsWriter;26pub const WriteBatch = store_mod.WriteBatch;27pub const FastForwardDecision = store_mod.FastForwardDecision;28pub const FastForwardRecovery = store_mod.FastForwardRecovery;29pub const FastForwardUpdate = store_mod.FastForwardUpdate;30pub const IncrementalBase = store_mod.IncrementalBase;31pub const refs = refs_mod;3233pub const repair = @import("repair.zig");

1pub const history = @import("history/root.zig");