tiny.sql.LifecycleSparseReadSession

1pub const SparseReadSession = struct {2    workspace: wal.Scanner.Workspace,3    file: file_mod.SparseReadOnlyDatabase = undefined,4    file_live: bool = false,56    pub fn init(self: *SparseReadSession, workspace: wal.Scanner.Workspace) void {7        self.* = .{ .workspace = workspace };8    }910    pub fn deinit(self: *SparseReadSession) void {11        self.resetFile();12        self.* = undefined;13    }1415    pub fn begin(16        self: *SparseReadSession,17        allocator: Allocator,18        dir: std.Io.Dir,19        options: SparseReadOptions,20    ) Error!SparseReadBeginResult {21        try options.control.check();22        const branch_state = switch (try loadSparseBranch(allocator, dir, options.read, options.control)) {23            .ready => |ready| ready,24            .repair_required => |reason| return .{ .repair_required = reason },25        };26        switch (try self.refreshFile(dir, options)) {27            .ready => {},28            .repair_required => |reason| return .{ .repair_required = reason },29        }30        try options.control.check();31        const catalog = catalog_mod.Reader.open(self.file.snapshot(), .{}) catch |err| {32            if (err == error.RecoveryRequired) {33                self.resetFile();34                return .moved;35            }36            return err;37        };38        var live_root = version.readDatabaseRootMaintained(39            allocator,40            &catalog,41            branch_state.conflicts,42        ) catch |err| {43            if (err == error.RecoveryRequired) {44                self.resetFile();45                return .moved;46            }47            return err;48        };49        defer live_root.deinit();50        try options.control.check();51        return .{ .ready = .{52            .catalog = catalog,53            .head = branch_state.head,54            .root = branch_state.root,55            .branch = branch_state,56            .live_root = live_root.hash,57        } };58    }5960    pub fn finish(61        self: *SparseReadSession,62        allocator: Allocator,63        dir: std.Io.Dir,64        assessment: SparseReadAssessment,65        options: SparseReadOptions,66    ) Error!SparseReadFinishResult {67        try options.control.check();68        const file_moved = switch (try self.refreshFile(dir, options)) {69            .ready => |state| state == .refreshed,70            .repair_required => |reason| return .{ .repair_required = reason },71        };72        const branch_state = switch (try loadSparseBranch(allocator, dir, options.read, options.control)) {73            .ready => |ready| ready,74            .repair_required => |reason| return .{ .repair_required = reason },75        };76        const catalog = catalog_mod.Reader.open(self.file.snapshot(), .{}) catch |err| {77            if (err == error.RecoveryRequired) {78                self.resetFile();79                return .moved;80            }81            return err;82        };83        var live_root = version.readDatabaseRootMaintained(84            allocator,85            &catalog,86            branch_state.conflicts,87        ) catch |err| {88            if (err == error.RecoveryRequired) {89                self.resetFile();90                return .moved;91            }92            return err;93        };94        defer live_root.deinit();95        try options.control.check();96        if (file_moved or97            !std.meta.eql(branch_state, assessment.branch) or98            !version.same(live_root.hash, assessment.live_root))99        {100            return .moved;101        }102        if (!version.same(live_root.hash, branch_state.root)) {103            return .{ .repair_required = .root_mismatch };104        }105        return .stable;106    }107108    fn refreshFile(109        self: *SparseReadSession,110        dir: std.Io.Dir,111        options: SparseReadOptions,112    ) Error!SparseRefreshResult {113        if (!self.file_live) {114            const opened = file_mod.SparseReadOnlyDatabase.openExisting(dir, .{115                .io = options.read.io,116                .paths = options.read.paths,117                .workspace = self.workspace,118                .control = options.control,119            }) catch |err| {120                self.resetFile();121                return err;122            };123            switch (opened) {124                .ready => |ready| {125                    self.file = ready;126                    self.file_live = true;127                    return .{ .ready = .refreshed };128                },129                .repair_required => |reason| return .{130                    .repair_required = .{ .file = reason },131                },132            }133        }134        const refreshed = self.file.refresh(dir, .{135            .paths = options.read.paths,136            .control = options.control,137        }) catch |err| {138            self.resetFile();139            return err;140        };141        return switch (refreshed) {142            .unchanged => .{ .ready = .unchanged },143            .refreshed => .{ .ready = .refreshed },144            .repair_required => |reason| repair: {145                self.resetFile();146                break :repair .{ .repair_required = .{ .file = reason } };147            },148        };149    }150151    fn resetFile(self: *SparseReadSession) void {152        if (self.file_live) self.file.deinit();153        self.file_live = false;154    }155};

1pub const LifecycleSparseReadSession = lifecycle.SparseReadSession;