tiny.glom.SearchStorage

1pub const Storage = struct {2    phase: alloc_phase.capacity.Phase,3    capacity: capacity_mod.Capacity,4    value: sql.TableValueStorage,5    query_workspace: []u8,6    presentation_workspace: []u8,7    in_use: bool = false,8    query_workspace_used_bytes: usize = 0,9    query_workspace_high_water_bytes: usize = 0,10    presentation_workspace_high_water_bytes: usize = 0,1112    pub const Limits: type = capacity_mod.Limits;13    pub const Capacity: type = capacity_mod.Capacity;14    pub const Exhaustion: type = @import("storage.zig").Exhaustion;15    pub const InitError: type = sql.TableValueStorage.InitError || capacity_mod.DeriveError;1617    pub const claim: alloc_phase.capacity.Declaration = .{18        .source = .{19            .id = "glom.search_storage",20            .kind = .phase_static,21            .limit_source = .caller,22            .storage = .{23                .covered = &.{24                    .{25                        .id = "one_reusable_encoded_glom_document_row_selected_by_25ef94074221",26                        .lifetime = .steady,27                        .detail = "one reusable encoded Glom document row selected by a native search hit",28                    },29                    .{30                        .id = "one_synchronous_sql_query_parse_ranking_snippet_res_bea48b4237d8",31                        .lifetime = .steady,32                        .detail = "one synchronous SQL query parse ranking snippet result and page workspace",33                    },34                    .{35                        .id = "one_result_dependent_json_full_or_table_presentatio_d1b34987da91",36                        .lifetime = .steady,37                        .detail = "one result-dependent JSON full or table presentation workspace selected by the command",38                    },39                },40                .excluded = &.{41                    "context document loading and context row storage",42                    "database WAL pager read cache file handles operating-system page cache and trace instrumentation",43                    "search-index corruption recovery search reference persistence checkpoint effects terminal writes and error diagnostics",44                },45            },46            .capacity = .{47                .inputs = &.{48                    alloc_phase.capacity.bindInput(Limits, "document_value_bytes", "document_value_bytes"),49                    alloc_phase.capacity.bindInput(Limits, "query_workspace_bytes", "query_workspace_bytes"),50                    alloc_phase.capacity.bindInput(Limits, "presentation_workspace_bytes", "presentation_workspace_bytes"),51                },52                .type_selectors = &.{},53                .nodes = &.{54                    .{ .input = 0 },55                    .{ .input = 1 },56                    .{ .input = 2 },57                    .{ .add = .{ .left = 0, .right = 1 } },58                    .{ .add = .{ .left = 3, .right = 2 } },59                },60                .assertions = &.{.{61                    .scope = .closure_total,62                    .measure = .retained,63                    .relation = .exact,64                    .expression = 4,65                }},66            },67            .overload = .{68                .kind = .terminal,69                .detail = "an oversized document or exhausted query or presentation region terminates the finite request before publication and release restores both workspaces",70            },71            .risks = .{72                .transitive = .{73                    .status = .witnessed,74                    .detail = "query preparation ranking candidate materialization snippets result placement and presentation use only the three sealed regions",75                },76                .foreign = .{77                    .status = .excluded,78                    .detail = "database file reads and operating-system cache state remain outside Glom search storage",79                },80            },81            .dependencies = &.{"sql.table_value_storage"},82            .obligations = &.{83                .{ .key = "glom_search_storage_capacity", .role = .capacity_model },84                .{ .key = "glom_search_storage_boundary", .role = .overload },85                .{ .key = "glom_search_storage_sealed", .role = .transitive_risk },86                .{ .key = "glom_search_storage_workspace_boundary", .role = .overload },87                .{ .key = "glom_search_storage_oom_retry", .role = .overload },88                .{ .key = "glom_search_storage_semantics", .role = .foreign_risk },89                .{ .key = "glom_search_storage_root", .role = .custom },90            },91        },92        .bindings = .{93            .owner = @This(),94            .seal = .{95                .family = alloc_phase.capacity.selector(@This().activate),96                .premise = .{97                    .class = .checked_semantic_fact,98                    .authority = .checker,99                },100            },101            .teardown = .{102                .family = alloc_phase.capacity.selector(@This().deinit),103                .premise = .{104                    .class = .checked_semantic_fact,105                    .authority = .checker,106                },107            },108        },109    };110111    pub fn init(allocator: std.mem.Allocator, limits: Limits) InitError!Storage {112        const capacity = try Capacity.derive(limits);113        const query_workspace = if (capacity.query_workspace_bytes == 0)114            @as([]u8, &.{})115        else116            try allocator.alloc(u8, capacity.query_workspace_bytes);117        errdefer if (query_workspace.len != 0) allocator.free(query_workspace);118        const presentation_workspace = if (capacity.presentation_workspace_bytes == 0)119            @as([]u8, &.{})120        else121            try allocator.alloc(u8, capacity.presentation_workspace_bytes);122        errdefer if (presentation_workspace.len != 0) allocator.free(presentation_workspace);123        return .{124            .phase = .initialization,125            .capacity = capacity,126            .value = try sql.TableValueStorage.init(allocator, .{127                .max_value_bytes = capacity.document_value_bytes,128            }),129            .query_workspace = query_workspace,130            .presentation_workspace = presentation_workspace,131        };132    }133134    pub fn activate(self: *Storage) void {135        std.debug.assert(self.phase == .initialization);136        self.value.activate();137        self.phase = .steady;138    }139140    pub fn get(141        self: *Storage,142        table: *const sql.RowIdTable,143        rowid: i64,144    ) !?[]const u8 {145        std.debug.assert(self.phase == .steady);146        return self.value.get(table, rowid) catch |err| switch (err) {147            error.ValueCapacityExceeded => error.SearchRowCapacityExceeded,148            else => err,149        };150    }151152    pub fn preflight(153        self: *const Storage,154        document_value_bytes: usize,155        query_workspace_bytes: usize,156        presentation_workspace_bytes: usize,157    ) Storage.Exhaustion!void {158        std.debug.assert(self.phase == .steady);159        if (self.in_use) return error.SearchStorageInUse;160        if (document_value_bytes > self.capacity.document_value_bytes) {161            return error.SearchRowCapacityExceeded;162        }163        if (query_workspace_bytes > self.capacity.query_workspace_bytes) {164            return error.SearchQueryCapacityExceeded;165        }166        if (presentation_workspace_bytes > self.capacity.presentation_workspace_bytes) {167            return error.SearchPresentationCapacityExceeded;168        }169    }170171    pub fn execute(172        self: *Storage,173        database: anytype,174        query: []const u8,175        filters: data.SearchFilters,176        comptime execute_fn: anytype,177    ) anyerror!data.SearchPage {178        std.debug.assert(self.phase == .steady);179        if (self.in_use) return error.SearchStorageInUse;180        self.in_use = true;181        var fixed = alloc_fixed.Tracked.init(self.query_workspace);182        errdefer {183            const workspace_status = fixed.status();184            self.query_workspace_used_bytes = workspace_status.used_bytes;185            self.query_workspace_high_water_bytes = @max(186                self.query_workspace_high_water_bytes,187                workspace_status.peak_bytes,188            );189            self.release();190        }191        const page = execute_fn(192            database,193            fixed.allocator(),194            self,195            query,196            filters,197        ) catch |err| switch (err) {198            error.OutOfMemory => return error.SearchQueryCapacityExceeded,199            else => return err,200        };201        const workspace_status = fixed.status();202        self.query_workspace_used_bytes = workspace_status.used_bytes;203        self.query_workspace_high_water_bytes = @max(204            self.query_workspace_high_water_bytes,205            workspace_status.peak_bytes,206        );207        return page;208    }209210    pub fn complete(211        self: *Storage,212        context: anytype,213        comptime complete_fn: anytype,214    ) anyerror!Completion {215        std.debug.assert(self.phase == .steady);216        std.debug.assert(self.in_use);217        var fixed = alloc_fixed.Tracked.init(self.presentation_workspace);218        defer {219            const workspace_status = fixed.status();220            self.presentation_workspace_high_water_bytes = @max(221                self.presentation_workspace_high_water_bytes,222                workspace_status.peak_bytes,223            );224        }225        var completion = complete_fn(fixed.allocator(), context) catch |err| switch (err) {226            error.OutOfMemory => return error.SearchPresentationCapacityExceeded,227            else => return err,228        };229        const workspace_status = fixed.status();230        completion.render_budget_bytes = self.capacity.presentation_workspace_bytes;231        completion.render_high_water_bytes = workspace_status.peak_bytes;232        return completion;233    }234235    pub fn release(self: *Storage) void {236        std.debug.assert(self.phase == .steady);237        std.debug.assert(self.in_use);238        self.query_workspace_high_water_bytes = @max(239            self.query_workspace_high_water_bytes,240            self.query_workspace_used_bytes,241        );242        self.query_workspace_used_bytes = 0;243        self.in_use = false;244    }245246    pub fn status(self: *const Storage) Status {247        return .{248            .phase = self.phase,249            .document_value_bytes = self.capacity.document_value_bytes,250            .query_workspace_bytes = self.capacity.query_workspace_bytes,251            .presentation_workspace_bytes = self.capacity.presentation_workspace_bytes,252            .storage_bytes = self.capacity.storage_bytes,253            .storage_pointer = @intFromPtr(self.value.bytes.ptr),254            .query_workspace_pointer = @intFromPtr(self.query_workspace.ptr),255            .presentation_workspace_pointer = @intFromPtr(self.presentation_workspace.ptr),256            .query_workspace_high_water_bytes = self.query_workspace_high_water_bytes,257            .presentation_workspace_high_water_bytes = self.presentation_workspace_high_water_bytes,258            .in_use = self.in_use,259        };260    }261262    pub fn deinit(self: *Storage, allocator: std.mem.Allocator) void {263        std.debug.assert(self.phase != .teardown);264        std.debug.assert(!self.in_use);265        self.phase = .teardown;266        self.value.deinit(allocator);267        if (self.presentation_workspace.len != 0) allocator.free(self.presentation_workspace);268        if (self.query_workspace.len != 0) allocator.free(self.query_workspace);269        self.* = undefined;270    }271};

1pub const SearchStorage = search.Storage;