tiny.sql.FileReadOnlyDatabase

1pub const ReadOnlyDatabase = struct {2    pub const Workspace = DatabaseWorkspace;34    storage: [@sizeOf(ReadOnlyState)]u8 align(@alignOf(ReadOnlyState)),56    pub fn openForTesting(7        allocator: Allocator,8        dir: std.Io.Dir,9        options: ReadOpenOptions,10    ) Error!ReadOpenResult {11        if (!builtin.is_test) @compileError("openForTesting is available only in tests");12        const workspace = try allocator.create(Workspace);13        errdefer allocator.destroy(workspace);14        workspace.* = try Workspace.allocate(allocator, .{15            .header = options.header,16            .max_wal_bytes = options.max_wal_bytes,17            .path_storage = .{18                .database_bytes = 0,19                .wal_bytes = 0,20            },21            .read_cache_pages = options.read_cache_capacity,22        });23        errdefer workspace.deallocate(allocator);24        const opened = try openExisting(allocator, workspace, dir, options);25        return switch (opened) {26            .ready => |ready| ready: {27                var database = ready;28                database.impl().testing_workspace_owned = true;29                break :ready .{ .ready = database };30            },31            .repair_required => |reason| repair: {32                workspace.deallocate(allocator);33                allocator.destroy(workspace);34                break :repair .{ .repair_required = reason };35            },36        };37    }3839    pub fn ownWorkspaceForTesting(self: *ReadOnlyDatabase) void {40        if (!builtin.is_test) @compileError("ownWorkspaceForTesting is available only in tests");41        const state = self.impl();42        std.debug.assert(!state.testing_workspace_owned);43        state.testing_workspace_owned = true;44    }4546    pub fn openExisting(47        allocator: Allocator,48        workspace: *Workspace,49        dir: std.Io.Dir,50        options: ReadOpenOptions,51    ) Error!ReadOpenResult {52        try options.control.check();53        var read_cache = try workspace.acquireReadCache(.{54            .pages = options.read_cache_capacity,55        });56        errdefer workspace.releaseReadCache(&read_cache);57        read_cache.activate();58        const recovered = try recoverReadOnly(allocator, workspace, dir, options);59        var recovered_pager = switch (recovered) {60            .repair_required => |reason| {61                workspace.releaseReadCache(&read_cache);62                return .{ .repair_required = reason };63            },64            .ready => |ready| ready,65        };66        errdefer workspace.release(&recovered_pager);67        try options.control.check();68        const base_file: ?std.Io.File = if (try filePresent(options.io, dir, options.paths.database))69            try dir.openFile(options.io, options.paths.database, .{})70        else71            null;72        errdefer if (base_file) |file| file.close(options.io);73        const view = (try recovered_pager.beginRead()).view;74        try options.control.check();75        var database: ReadOnlyDatabase = undefined;76        database.impl().* = .{77            .allocator = allocator,78            .workspace = workspace,79            .io = options.io,80            .base_file = base_file,81            .pager = recovered_pager,82            .read_cache = read_cache,83            .view = view,84        };85        return .{ .ready = database };86    }8788    pub fn deinit(self: *ReadOnlyDatabase) void {89        const state = self.impl();90        const allocator = state.allocator;91        const workspace = state.workspace;92        const testing_workspace_owned = if (builtin.is_test)93            state.testing_workspace_owned94        else95            false;96        if (state.base_file) |file| file.close(state.io);97        state.workspace.release(&state.pager);98        state.workspace.releaseReadCache(&state.read_cache);99        self.* = undefined;100        if (testing_workspace_owned) {101            workspace.deallocate(allocator);102            allocator.destroy(workspace);103        }104    }105106    pub fn snapshot(self: *ReadOnlyDatabase) Snapshot {107        const state = self.impl();108        return .{109            .source = .{ .durable = .{110                .io = state.io,111                .base_file = if (state.base_file) |*file| file else null,112                .pager = &state.pager,113                .read_cache = &state.read_cache,114            } },115            .view = state.view,116        };117    }118119    pub fn readCacheCapacity(self: *const ReadOnlyDatabase) usize {120        return self.implConst().read_cache.capacity.pages;121    }122123    fn impl(self: *ReadOnlyDatabase) *ReadOnlyState {124        return @ptrCast(&self.storage);125    }126127    fn implConst(self: *const ReadOnlyDatabase) *const ReadOnlyState {128        return @ptrCast(&self.storage);129    }130};

1pub const FileReadOnlyDatabase = file.ReadOnlyDatabase;