tiny.sql.Relation

1pub const Relation = struct {2    space: space_mod.Space,3    table: table_mod.Table,4    indexes: [max_indexes]Indexed = undefined,5    index_count: usize,67    pub fn open(space: *const space_mod.Space, options: Options) Error!Relation {8        if (options.indexes.len > max_indexes) return error.TooManyIndexes;9        var relation = Relation{10            .space = space.*,11            .table = try space.rowidTable(options.table_root),12            .index_count = options.indexes.len,13        };14        for (options.indexes, 0..) |spec, offset| {15            if (spec.fields.len > max_index_fields) return error.TooManyIndexFields;16            relation.indexes[offset] = .{17                .index = try space.index(spec.root_page, spec.columns),18                .fields = spec.fields,19            };20        }21        return relation;22    }2324    pub fn reader(self: *const Relation, snapshot: file.Snapshot) Error!Reader {25        const opened_space = try self.space.reader(snapshot);26        var opened = Reader{27            .space = opened_space,28            .table = try opened_space.rowidTable(self.table.rows.root_page),29            .index_count = self.index_count,30        };31        for (0..self.index_count) |offset| {32            opened.indexes[offset] = .{33                .index = try opened_space.index(34                    self.indexes[offset].index.entries.root_page,35                    self.indexes[offset].index.columns,36                ),37                .fields = self.indexes[offset].fields,38            };39        }40        return opened;41    }4243    pub fn put(self: *Relation, allocator: Allocator, rowid: i64, values: []const row.Value, options: file.CommitOptions) Error!file.Commit {44        const phase = trace.scope("relation.put");45        defer phase.end();4647        const bytes = try allocator.alloc(u8, try row.encodedSize(values));48        defer allocator.free(bytes);49        const encoded = try row.encode(bytes, values);50        return try self.applyEdits(allocator, &.{.{ .put = .{51            .rowid = rowid,52            .bytes = encoded,53        } }}, options);54    }5556    pub fn putEncoded(self: *Relation, allocator: Allocator, rowid: i64, bytes: []const u8, options: file.CommitOptions) Error!file.Commit {57        const phase = trace.scope("relation.put_encoded");58        defer phase.end();5960        return try self.applyEdits(allocator, &.{.{ .put = .{61            .rowid = rowid,62            .bytes = bytes,63        } }}, options);64    }6566    pub fn update(self: *Relation, allocator: Allocator, rowid: i64, assignments: []const Edit.Assignment, options: file.CommitOptions) Error!file.Commit {67        const phase = trace.scope("relation.update");68        defer phase.end();6970        return try self.applyEdits(allocator, &.{.{ .update = .{71            .rowid = rowid,72            .assignments = assignments,73        } }}, options);74    }7576    pub fn delete(self: *Relation, allocator: Allocator, rowid: i64, options: file.CommitOptions) Error!file.Commit {77        const phase = trace.scope("relation.delete");78        defer phase.end();7980        return try self.applyEdits(allocator, &.{.{ .delete = rowid }}, options);81    }8283    pub fn applyEdits(self: *Relation, allocator: Allocator, edits: []const Edit, options: file.CommitOptions) Error!file.Commit {84        const phase = trace.scope("relation.apply_edits");85        defer phase.end();8687        var write = try self.space.beginWrite();88        defer write.deinit();89        try self.applyEditsIn(allocator, &write, edits);90        return try write.commit(options);91    }9293    pub fn applyEditsIn(94        self: *Relation,95        allocator: Allocator,96        write: *tree.Write,97        edits: []const Edit,98    ) Error!void {99        const phase = trace.scope("relation.apply_edits_in");100        defer phase.end();101        try write.claimBatch(self.table.rows.root_page);102103        var states: std.AutoArrayHashMapUnmanaged(i64, AppliedEdit) = .empty;104        defer {105            for (states.values()) |*state| state.deinit(allocator);106            states.deinit(allocator);107        }108109        const base_reader = try self.reader(write.snapshot);110        for (edits) |edit| {111            try accumulateEdit(allocator, &base_reader, &states, edit);112        }113        for (states.values()) |state| try self.applyEditStateIn(write, state);114    }115116    pub fn lastRowId(self: *const Relation) Error!?i64 {117        var read = try self.space.database.beginRead();118        defer read.deinit();119        const opened = try self.reader(read.snapshot());120        return try opened.lastRowId();121    }122123    pub fn get(self: *const Relation, allocator: Allocator, rowid: i64) Error!?[]u8 {124        var read = try self.space.database.beginRead();125        defer read.deinit();126        const opened = try self.reader(read.snapshot());127        return try opened.get(allocator, rowid);128    }129130    pub fn valueLength(self: *const Relation, rowid: i64) Error!?usize {131        var read = try self.space.database.beginRead();132        defer read.deinit();133        const opened = try self.reader(read.snapshot());134        return try opened.valueLength(rowid);135    }136137    pub fn getInto(self: *const Relation, rowid: i64, target: []u8) Error!?[]u8 {138        var read = try self.space.database.beginRead();139        defer read.deinit();140        const opened = try self.reader(read.snapshot());141        return try opened.getInto(rowid, target);142    }143144    pub fn scan(145        self: *const Relation,146        target: *Scan,147        allocator: Allocator,148        start: ?i64,149        end: ?i64,150    ) Error!void {151        var read = try self.space.database.beginRead();152        defer read.deinit();153        const opened = try self.reader(read.snapshot());154        try opened.scan(target, allocator, start, end);155    }156157    pub fn scanProjected(158        self: *const Relation,159        target: *Scan,160        allocator: Allocator,161        start: ?i64,162        end: ?i64,163        projection: table_mod.Projection,164    ) Error!void {165        var read = try self.space.database.beginRead();166        defer read.deinit();167        const opened = try self.reader(read.snapshot());168        try opened.scanProjected(target, allocator, start, end, projection);169    }170171    pub fn lookup(172        self: *const Relation,173        target: *index_mod.Scan,174        allocator: Allocator,175        index_slot: usize,176        prefix: []const row.Value,177    ) Error!void {178        var read = try self.space.database.beginRead();179        defer read.deinit();180        const opened = try self.reader(read.snapshot());181        try opened.lookup(target, allocator, index_slot, prefix);182    }183184    pub fn indexScan(185        self: *const Relation,186        target: *index_mod.Scan,187        allocator: Allocator,188        index_slot: usize,189        start: ?[]const row.Value,190        end: ?[]const row.Value,191    ) Error!void {192        var read = try self.space.database.beginRead();193        defer read.deinit();194        const opened = try self.reader(read.snapshot());195        try opened.indexScan(target, allocator, index_slot, start, end);196    }197198    pub fn indexRange(199        self: *const Relation,200        target: *index_mod.Scan,201        allocator: Allocator,202        index_slot: usize,203        start: ?index_mod.Bound,204        end: ?index_mod.Bound,205    ) Error!void {206        var read = try self.space.database.beginRead();207        defer read.deinit();208        const opened = try self.reader(read.snapshot());209        try opened.indexRange(target, allocator, index_slot, start, end);210    }211212    pub fn summarize(self: *const Relation) Error!Summary {213        var read = try self.space.database.beginRead();214        defer read.deinit();215        const opened = try self.reader(read.snapshot());216        return try opened.summarize();217    }218219    pub fn validateIndexes(self: *const Relation, allocator: Allocator) Error!void {220        const phase = trace.scope("relation.validate_indexes");221        defer phase.end();222223        var table_scan: Scan = undefined;224        try self.scan(&table_scan, allocator, null, null);225        defer table_scan.deinit();226        while (try table_scan.next()) |entry| {227            const view = try entry.view();228            var index_offset: usize = 0;229            while (index_offset < self.index_count) : (index_offset += 1) {230                const indexed = &self.indexes[index_offset];231                var projected: [max_index_fields]row.Value = undefined;232                const values = try projectView(view, indexed.fields, &projected);233                if (!try indexContainsRowid(allocator, &indexed.index, values, entry.rowid)) return error.SecondaryIndexCorrupt;234            }235        }236237        var index_offset: usize = 0;238        while (index_offset < self.index_count) : (index_offset += 1) {239            const indexed = &self.indexes[index_offset];240            var index_scan: index_mod.Scan = undefined;241            try indexed.index.scan(&index_scan, allocator, null, null);242            defer index_scan.deinit();243            while (try index_scan.next()) |entry| {244                const bytes = (try self.table.get(allocator, entry.rowid)) orelse return error.SecondaryIndexCorrupt;245                defer allocator.free(bytes);246                const view = try row.View.init(bytes);247                var projected: [max_index_fields]row.Value = undefined;248                const values = try projectView(view, indexed.fields, &projected);249                var decoded_values: [max_index_fields]row.Value = undefined;250                var scratch: [page.size]u8 = undefined;251                const decoded = try key.decodeIndex(decoded_values[0..], scratch[0..], entry.key);252                const valid = decoded.rowid == entry.rowid and valuesEqual(values, decoded.values, indexed.index.columns);253                if (!valid) return error.SecondaryIndexCorrupt;254            }255        }256    }257258    fn putViewIndexesIn(self: *Relation, write: *tree.Write, rowid: i64, view: row.View) Error!void {259        var offset: usize = 0;260        while (offset < self.index_count) : (offset += 1) {261            var projected: [max_index_fields]row.Value = undefined;262            const indexed = try projectView(view, self.indexes[offset].fields, &projected);263            try self.indexes[offset].index.putIn(write, rowid, indexed);264        }265    }266267    fn deleteIndexesIn(self: *Relation, write: *tree.Write, rowid: i64, view: row.View) Error!void {268        var offset: usize = 0;269        while (offset < self.index_count) : (offset += 1) {270            var projected: [max_index_fields]row.Value = undefined;271            const indexed = try projectView(view, self.indexes[offset].fields, &projected);272            try self.indexes[offset].index.deleteIn(write, rowid, indexed);273        }274    }275276    fn accumulateEdit(277        allocator: Allocator,278        base_reader: *const Reader,279        states: *std.AutoArrayHashMapUnmanaged(i64, AppliedEdit),280        edit: Edit,281    ) Error!void {282        const state = try appliedEdit(283            allocator,284            base_reader,285            states,286            editRowid(edit),287        );288        switch (edit) {289            .put => |put_edit| {290                _ = try row.View.init(put_edit.bytes);291                state.current = put_edit.bytes;292            },293            .update => |update_edit| {294                const current = state.current orelse return error.KeyNotFound;295                state.adoptMerged(allocator, try applyUpdate(allocator, current, update_edit.assignments));296            },297            .delete => {298                if (state.current == null) return error.KeyNotFound;299                state.current = null;300            },301        }302    }303304    fn appliedEdit(305        allocator: Allocator,306        base_reader: *const Reader,307        states: *std.AutoArrayHashMapUnmanaged(i64, AppliedEdit),308        rowid: i64,309    ) Error!*AppliedEdit {310        if (states.getPtr(rowid)) |state| return state;311312        const base = try base_reader.get(allocator, rowid);313        errdefer if (base) |bytes| allocator.free(bytes);314        try states.putNoClobber(allocator, rowid, .{315            .rowid = rowid,316            .base = base,317            .current = if (base) |bytes| bytes else null,318        });319        return states.getPtr(rowid).?;320    }321322    fn applyEditStateIn(self: *Relation, write: *tree.Write, state: AppliedEdit) Error!void {323        if (state.base) |base| {324            if (state.current) |current| {325                if (std.mem.eql(u8, base, current)) return;326                try self.deleteIndexesIn(write, state.rowid, try row.View.init(base));327                try self.table.putEncodedIn(write, state.rowid, current);328                try self.putViewIndexesIn(write, state.rowid, try row.View.init(current));329            } else {330                try self.deleteIndexesIn(write, state.rowid, try row.View.init(base));331                try self.table.deleteIn(write, state.rowid);332            }333        } else if (state.current) |current| {334            try self.table.putEncodedIn(write, state.rowid, current);335            try self.putViewIndexesIn(write, state.rowid, try row.View.init(current));336        }337    }338};

1pub const Relation = relation.Relation;