tiny.sql.DatabaseWrite

1pub const DatabaseWrite = struct {2    pub const Limits = staging.Limits;3    pub const Capacity = staging.Capacity;4    pub const Demand = staging.Storage.Demand;5    pub const StagedEdits = staging.Storage.Iterator;6    pub const Workspace = staging.Workspace;78    session: *DatabaseSession,9    generation: u64,10    active: bool = true,1112    pub fn deinit(self: *DatabaseWrite) void {13        self.discard();14        self.* = undefined;15    }1617    pub fn stageRelation(self: *DatabaseWrite, relation: *relation_session.RelationSession) DatabaseError!void {18        std.debug.assert(self.active);19        try self.session.stageRelation(&self.state().storage, relation);20    }2122    pub fn ensure(self: *const DatabaseWrite, demand: Demand) DatabaseError!void {23        std.debug.assert(self.active);24        try self.stateConst().storage.ensure(demand);25    }2627    pub fn stagedRelationRoot(self: *DatabaseWrite, name: []const u8) ?*const version.RelationRoot {28        _ = self.state();29        const staged = self.session.stagedRelation(name) orelse return null;30        return &staged.root;31    }3233    pub fn stagedRelationEdits(self: *DatabaseWrite, name: []const u8) ?StagedEdits {34        std.debug.assert(self.active);35        const relation_index = self.session.stagedRelationIndex(name) orelse return null;36        return self.state().storage.iterator(relation_index);37    }3839    pub fn stagePut(self: *DatabaseWrite, name: []const u8, rowid: i64, values: []const row.Value) DatabaseError!void {40        const phase = trace.scope("session.database.stage_put");41        defer phase.end();4243        std.debug.assert(self.active);44        const relation_index = self.session.stagedRelationIndex(name) orelse return error.NoStagedRelation;45        try self.state().storage.appendPut(relation_index, rowid, values);46    }4748    pub fn stageUpdate(self: *DatabaseWrite, name: []const u8, rowid: i64, assignments: []const relation_mod.Edit.Assignment) DatabaseError!void {49        const phase = trace.scope("session.database.stage_update");50        defer phase.end();5152        std.debug.assert(self.active);53        const relation_index = self.session.stagedRelationIndex(name) orelse return error.NoStagedRelation;54        try self.state().storage.appendUpdate(relation_index, rowid, assignments);55    }5657    pub fn stageDelete(self: *DatabaseWrite, name: []const u8, rowid: i64) DatabaseError!void {58        const phase = trace.scope("session.database.stage_delete");59        defer phase.end();6061        std.debug.assert(self.active);62        const relation_index = self.session.stagedRelationIndex(name) orelse return error.NoStagedRelation;63        try self.state().storage.appendDelete(relation_index, rowid);64    }6566    pub fn flush(self: *DatabaseWrite) DatabaseError!DatabaseFlush {67        std.debug.assert(self.active);68        const active_write = self.state();69        const flush_value = try self.session.flushStagedRelations(70            active_write.flush_allocator,71            active_write.options,72            &active_write.storage,73        );74        active_write.workspace.release(&active_write.storage);75        self.session.active_write = null;76        self.active = false;77        return flush_value;78    }7980    pub fn flushRelation(self: *DatabaseWrite, relation: *relation_session.RelationSession) DatabaseError!relation_session.RelationFlush {81        std.debug.assert(self.active);82        try self.stageRelation(relation);83        var flush_value = try self.flush();84        defer flush_value.deinit();85        return flush_value.onlyRelation();86    }8788    pub fn pendingRelations(self: *const DatabaseWrite) usize {89        _ = self.stateConst();90        return self.session.pendingRelations();91    }9293    pub fn discard(self: *DatabaseWrite) void {94        if (!self.active) return;95        if (self.session.active_write) |*active_write| {96            if (active_write.generation == self.generation) {97                self.session.discardStagedRelations();98                self.session.discardWrite();99            }100        }101        self.active = false;102    }103104    fn state(self: *DatabaseWrite) *ActiveWrite {105        std.debug.assert(self.active);106        const active_write = &self.session.active_write.?;107        std.debug.assert(active_write.generation == self.generation);108        return active_write;109    }110111    fn stateConst(self: *const DatabaseWrite) *const ActiveWrite {112        std.debug.assert(self.active);113        const active_write = &self.session.active_write.?;114        std.debug.assert(active_write.generation == self.generation);115        return active_write;116    }117};

1pub const DatabaseWrite = session.DatabaseWrite;