tiny.smg.SearchDocumentPlan

1pub const DocumentPlan = struct {2    pub const Limits = struct {3        documents: usize,4        text_bytes: usize,5    };67    pub const Capacity = struct {8        documents: usize,9        text_bytes: usize,10        bytes: usize,1112        pub fn derive(limits: Limits) error{CapacityOverflow}!Capacity {13            const document_bytes = try alloc_phase.capacity.mul(14                usize,15                limits.documents,16                @sizeOf(sql.SearchDocument),17            );18            return .{19                .documents = limits.documents,20                .text_bytes = limits.text_bytes,21                .bytes = try alloc_phase.capacity.add(22                    usize,23                    document_bytes,24                    limits.text_bytes,25                ),26            };27        }28    };2930    pub const InitError = std.mem.Allocator.Error || error{CapacityOverflow};3132    pub const claim: alloc_phase.capacity.Declaration = .{33        .source = .{34            .id = "smg.search_document_plan",35            .kind = .phase_static,36            .limit_source = .caller,37            .storage = .{38                .covered = &.{39                    .{40                        .id = "one_search_document_record_per_persisted_node_row",41                        .lifetime = .steady,42                        .detail = "one search document record per persisted node row",43                    },44                    .{45                        .id = "one_contiguous_bounded_search_text_region_admitted_bf91a1d01c82",46                        .lifetime = .steady,47                        .detail = "one contiguous bounded search-text region admitted from exact row views",48                    },49                },50                .excluded = &.{51                    "persisted graph relation scans and borrowed row bytes",52                    "graph database pager catalog and operating-system read storage",53                    "SQL search postings keys lengths write staging WAL and cache database",54                },55            },56            .capacity = .{57                .inputs = &.{58                    alloc_phase.capacity.bindInput(Limits, "documents", "documents"),59                    alloc_phase.capacity.bindInput(Limits, "text_bytes", "text_bytes"),60                },61                .type_selectors = &.{62                    alloc_phase.capacity.bindType(sql.SearchDocument, "search_document"),63                },64                .nodes = &.{65                    .{ .input = 0 },66                    .{ .scale = .{ .node = 0, .coefficient = .{ .size_of_concrete_type = 0 } } },67                    .{ .input = 1 },68                    .{ .add = .{ .left = 1, .right = 2 } },69                },70                .assertions = &.{.{71                    .scope = .closure_total,72                    .measure = .retained,73                    .relation = .upper_bound,74                    .expression = 3,75                }},76            },77            .overload = .{78                .kind = .reject_before_seal,79                .detail = "checked record and rendered-text arithmetic plus exact acquisitions reject overflow or OOM before the second relation pass",80            },81            .risks = .{82                .transitive = .{83                    .status = .open,84                    .detail = "identifier rendering and row views are sealed in the witness but lack a transitive allocation-closure certificate",85                },86                .foreign = .{87                    .status = .excluded,88                    .detail = "graph and search database effects occur outside the plan-owned slices",89                },90            },91            .obligations = &.{92                .{ .key = "smg_search_document_plan_capacity_capacity_model", .role = .capacity_model },93                .{ .key = "smg_search_document_plan_capacity_overload", .role = .overload },94                .{ .key = "smg_search_document_plan_oom", .role = .overload },95                .{ .key = "smg_search_document_plan_sealed", .role = .transitive_risk },96                .{ .key = "smg_search_document_plan_integration", .role = .foreign_risk },97            },98        },99        .bindings = .{100            .owner = @This(),101            .seal = .{102                .family = alloc_phase.capacity.selector(@This().activate),103                .premise = .{104                    .class = .checked_semantic_fact,105                    .authority = .checker,106                },107            },108            .teardown = .{109                .family = alloc_phase.capacity.selector(@This().deinit),110                .premise = .{111                    .class = .checked_semantic_fact,112                    .authority = .checker,113                },114            },115        },116    };117118    phase: alloc_phase.capacity.Phase,119    capacity: Capacity,120    documents: []sql.SearchDocument,121    text: []u8,122    documents_filled: usize,123    text_filled: usize,124125    pub fn init(allocator: std.mem.Allocator, limits: Limits) InitError!DocumentPlan {126        const capacity = try Capacity.derive(limits);127        const documents = try documentAllocSlice(sql.SearchDocument, allocator, capacity.documents);128        errdefer documentFreeSlice(sql.SearchDocument, allocator, documents);129        return .{130            .phase = .initialization,131            .capacity = capacity,132            .documents = documents,133            .text = try documentAllocSlice(u8, allocator, capacity.text_bytes),134            .documents_filled = 0,135            .text_filled = 0,136        };137    }138139    pub fn append(self: *DocumentPlan, rowid: i64, name: []const u8, docstring: ?[]const u8) error{CapacityOverflow}!void {140        std.debug.assert(self.phase == .initialization);141        if (self.documents_filled == self.documents.len) return error.CapacityOverflow;142        const text_bytes = try nodeSearchTextBytes(name, docstring);143        const text_end = std.math.add(usize, self.text_filled, text_bytes) catch return error.CapacityOverflow;144        if (text_end > self.text.len) return error.CapacityOverflow;145        const destination = self.text[self.text_filled..text_end];146        fillNodeSearchText(destination, name, docstring);147        self.documents[self.documents_filled] = .{ .rowid = rowid, .text = destination };148        self.documents_filled += 1;149        self.text_filled = text_end;150    }151152    pub fn activate(self: *DocumentPlan) void {153        std.debug.assert(self.phase == .initialization);154        std.debug.assert(self.documents_filled == self.documents.len);155        std.debug.assert(self.text_filled == self.text.len);156        self.phase = .steady;157    }158159    pub fn deinit(self: *DocumentPlan, allocator: std.mem.Allocator) void {160        std.debug.assert(self.phase != .teardown);161        self.phase = .teardown;162        documentFreeSlice(sql.SearchDocument, allocator, self.documents);163        documentFreeSlice(u8, allocator, self.text);164        self.* = undefined;165    }166};

1pub const SearchDocumentPlan = @import("search.zig").DocumentPlan;