tiny.sql.PreparedRelation

1pub const PreparedRelation = struct {2    allocator: Allocator,3    catalog: catalog_mod.Catalog,4    name: []u8,5    schema: catalog_mod.Schema,6    handle: catalog_mod.RelationHandle,7    stats: ?catalog_mod.RelationStats,8    root: ?version.RelationRoot,9    key: PlanKey,10    validation: Validation = .content,1112    pub fn deinit(self: *PreparedRelation) void {13        if (self.root) |*root| root.deinit();14        if (self.stats) |*stats| stats.deinit();15        self.handle.deinit();16        self.allocator.free(self.name);17        self.* = undefined;18    }1920    pub fn validate(self: *PreparedRelation) Error!void {21        const phase = trace.scope("plan.validate_relation");22        defer phase.end();2324        const current = try self.currentCacheKey();25        if (!PlanKey.same(current, self.key)) return error.PlanChanged;26    }2728    pub fn execute(self: *PreparedRelation) Error!RelationRead {29        const phase = trace.scope("plan.execute_relation");30        defer phase.end();3132        try self.validate();33        var lease = try self.handle.relation.space.database.beginRead();34        errdefer lease.deinit();35        return .{36            .lease = lease,37            .execution = .{38                .reader = try self.handle.relation.reader(lease.snapshot()),39            },40        };41    }4243    pub fn relationStats(self: *const PreparedRelation) ?*const catalog_mod.RelationStats {44        if (self.stats) |*stats| return stats;45        return null;46    }4748    pub fn cacheKey(self: *const PreparedRelation) PlanKey {49        return self.key;50    }5152    pub fn currentCacheKey(self: *PreparedRelation) Error!PlanKey {53        var state = try self.catalog.readRelation(self.allocator, self.name);54        defer state.deinit();55        return switch (self.validation) {56            .content => content_key: {57                const relation_key = try version.relationKey(58                    self.name,59                    &state.handle,60                    state.relationStats(),61                );62                break :content_key PlanKey.fromRelationKey(relation_key, self.key.parameters);63            },64            .shape => shapeKey(65                self.name,66                &state.handle,67                state.relationStats(),68                self.key.parameters,69            ),70        };71    }7273    pub fn matchesRoot(self: *const PreparedRelation, root: *const version.RelationRoot) bool {74        if (self.root == null) return false;75        return PlanKey.same(self.key, PlanKey.fromRoot(root, self.key.parameters));76    }7778    pub fn writeSession(self: *PreparedRelation) Error!session_mod.RelationSession {79        const phase = trace.scope("plan.write_session");80        defer phase.end();8182        var relation_session = try session_mod.RelationSession.open(self.allocator, &self.catalog, self.name);83        errdefer relation_session.deinit();84        if (!self.matchesRoot(&relation_session.root)) return error.PlanChanged;85        return relation_session;86    }8788    pub fn refresh(self: *PreparedRelation) Error!void {89        var state = try self.catalog.readRelation(self.allocator, self.name);90        errdefer state.deinit();91        var root: ?version.RelationRoot = null;92        errdefer if (root) |*relation_root| relation_root.deinit();93        const key = switch (self.validation) {94            .content => key: {95                root = try version.relationRootMaintained(96                    self.allocator,97                    self.name,98                    state.schema,99                    &state.handle,100                    state.relationStats(),101                );102                break :key PlanKey.fromRoot(&root.?, self.key.parameters);103            },104            .shape => shapeKey(105                self.name,106                &state.handle,107                state.relationStats(),108                self.key.parameters,109            ),110        };111112        if (self.root) |*old_root| old_root.deinit();113        if (self.stats) |*old_stats| old_stats.deinit();114        self.handle.deinit();115        self.schema = state.schema;116        self.handle = state.handle;117        self.stats = state.stats;118        self.root = root;119        self.key = key;120    }121122    pub fn get(self: *PreparedRelation, allocator: Allocator, rowid: i64) Error!?[]u8 {123        var execution = try self.execute();124        defer execution.deinit();125        return try execution.get(allocator, rowid);126    }127128    pub fn scan(129        self: *PreparedRelation,130        target: *relation_mod.Scan,131        allocator: Allocator,132        start: ?i64,133        end: ?i64,134    ) Error!void {135        var execution = try self.execute();136        defer execution.deinit();137        try execution.scan(target, allocator, start, end);138    }139140    pub fn lookup(141        self: *PreparedRelation,142        target: *index_mod.Scan,143        allocator: Allocator,144        index_slot: usize,145        prefix: []const row.Value,146    ) Error!void {147        var execution = try self.execute();148        defer execution.deinit();149        try execution.lookup(target, allocator, index_slot, prefix);150    }151152    pub fn indexScan(153        self: *PreparedRelation,154        target: *index_mod.Scan,155        allocator: Allocator,156        index_slot: usize,157        start: ?[]const row.Value,158        end: ?[]const row.Value,159    ) Error!void {160        var execution = try self.execute();161        defer execution.deinit();162        try execution.indexScan(target, allocator, index_slot, start, end);163    }164165    pub fn indexRange(166        self: *PreparedRelation,167        target: *index_mod.Scan,168        allocator: Allocator,169        index_slot: usize,170        start: ?index_mod.Bound,171        end: ?index_mod.Bound,172    ) Error!void {173        var execution = try self.execute();174        defer execution.deinit();175        try execution.indexRange(target, allocator, index_slot, start, end);176    }177};

1pub const PreparedRelation = plan.PreparedRelation;