tiny.sql.Catalog

1pub const Catalog = struct {2    database: *file.Database,3    meta_page: u32,4    root_page: u32,5    schema: table.Table,67    pub fn open(database: *file.Database, options: Options) Error!Catalog {8        try validateOptions(options);9        return .{10            .database = database,11            .meta_page = options.meta_page,12            .root_page = options.root_page,13            .schema = try table.Table.open(database, .{14                .tree = catalogTreeOptions(options),15            }),16        };17    }1819    pub fn schemaState(self: *const Catalog, allocator: Allocator) Error!Schema {20        return try readSchemaState(&self.schema, allocator);21    }2223    pub fn beginMaterialization(self: *const Catalog, allocator: Allocator) Error!Materialization {24        var roots: [space_mod.max_roots]space_mod.RootSpec = undefined;25        var root_count: usize = 0;26        try addRoot(&roots, &root_count, .{ .root_page = self.root_page });2728        var state = CatalogState{};29        var scan: table.Scan = undefined;30        try self.schema.scan(&scan, allocator, null, null);31        defer scan.deinit();32        while (try scan.next()) |entry| {33            var scratch = CatalogScratch{};34            switch (try state.record(entry, &scratch)) {35                .schema, .stats => {},36                .object => |object| try addRoot(&roots, &root_count, .{37                    .root_page = object.root_page,38                    .identity_page = object.identity_page,39                }),40            }41        }42        const current_schema = try state.schemaOrDefault();43        if (state.max_rowid == std.math.maxInt(i64)) return error.CatalogCorrupt;4445        const space = try space_mod.Space.open(self.database, .{46            .meta_page = self.meta_page,47            .roots = roots[0..root_count],48        });49        var write = try space.beginWrite();50        errdefer write.deinit();51        return .{52            .allocator = allocator,53            .catalog = self,54            .roots = roots,55            .root_count = root_count,56            .schema = try space.rowidTable(self.root_page),57            .write = write,58            .current_schema = current_schema,59            .next_rowid = @max(state.max_rowid + 1, first_object_rowid),60        };61    }6263    pub fn prepareRelationStats(64        _: *const Catalog,65        allocator: Allocator,66        definition: RelationDefinition,67        puts: []const relation_mod.Edit.Put,68        table_summary: tree.Summary,69        index_summaries: []const tree.Summary,70    ) Error!PreparedRelationStats {71        try validateDefinition(definition);72        if (definition.indexes.len != index_summaries.len) return error.CatalogCorrupt;7374        var previous_rowid: ?i64 = null;75        for (puts) |put| {76            _ = try row.View.init(put.bytes);77            if (previous_rowid) |previous| {78                if (put.rowid <= previous) return error.CatalogCorrupt;79            }80            previous_rowid = put.rowid;81        }8283        const indexes = try allocator.alloc(IndexStats, definition.indexes.len);84        var index_count: usize = 0;85        errdefer {86            for (indexes[0..index_count]) |*index_stats| {87                allocator.free(index_stats.name);88                freeIndexDistribution(allocator, index_stats.distribution);89            }90            allocator.free(indexes);91        }9293        const distribution_blobs = try allocator.alloc([]u8, definition.indexes.len);94        var blob_count: usize = 0;95        errdefer {96            for (distribution_blobs[0..blob_count]) |bytes| {97                if (bytes.len != 0) allocator.free(bytes);98            }99            allocator.free(distribution_blobs);100        }101102        for (103            definition.indexes,104            index_summaries,105            indexes,106            distribution_blobs,107            0..,108        ) |index_definition, summary, *index_stats, *distribution_blob, index_offset| {109            const prepared = try prepareIndexStats(110                allocator,111                index_definition,112                puts,113                summary,114                index_offset,115            );116            index_stats.* = prepared.stats;117            distribution_blob.* = prepared.distribution_blob;118            index_count += 1;119            blob_count += 1;120        }121122        return .{123            .allocator = allocator,124            .stats = .{125                .allocator = allocator,126                .table_root_page = 0,127                .table = table_summary,128                .indexes = indexes,129            },130            .distribution_blobs = distribution_blobs,131        };132    }133134    pub fn createRelation(self: *const Catalog, allocator: Allocator, definition: RelationDefinition, options: file.CommitOptions) Error!Commit {135        const phase = trace.scope("catalog.create_relation");136        defer phase.end();137138        try validateDefinition(definition);139140        var roots: [space_mod.max_roots]space_mod.RootSpec = undefined;141        var root_count: usize = 0;142        try addRoot(&roots, &root_count, .{ .root_page = self.root_page });143144        var state = CatalogState{};145        {146            var scan: table.Scan = undefined;147            try self.schema.scan(&scan, allocator, null, null);148            defer scan.deinit();149            while (try scan.next()) |entry| {150                var scratch = CatalogScratch{};151                switch (try state.record(entry, &scratch)) {152                    .schema => {},153                    .object => |object| {154                        if (std.mem.eql(u8, object.name, definition.name)) return error.ObjectExists;155                        for (definition.indexes) |index_definition| {156                            if (std.mem.eql(u8, object.name, index_definition.name)) return error.ObjectExists;157                        }158                        try addRoot(&roots, &root_count, .{ .root_page = object.root_page, .identity_page = object.identity_page });159                    },160                    .stats => {},161                }162            }163        }164        const next_schema = try bumpSchemaVersion(try state.schemaOrDefault());165166        const space = try space_mod.Space.open(self.database, .{167            .meta_page = self.meta_page,168            .roots = roots[0..root_count],169        });170        var schema = try space.rowidTable(self.root_page);171        var write = try space.beginWrite();172        defer write.deinit();173174        const table_root = try allocateCatalogRoot(&write, &roots, &root_count);175        var index_roots: [relation_mod.max_indexes]space_mod.RootSpec = undefined;176        for (definition.indexes, 0..) |_, index_offset| {177            index_roots[index_offset] = try allocateCatalogRoot(&write, &roots, &root_count);178        }179180        try putSchemaRow(&schema, &write, next_schema);181182        var definitions_buffer: [page.size]u8 = undefined;183        const definitions = try encodeDefinitions(&definitions_buffer, definition.columns);184        var next_rowid = @max(state.max_rowid + 1, first_object_rowid);185        try putCatalogRow(&schema, &write, next_rowid, relation_kind, definition.name, definition.name, table_root.root_page, table_root.identity_page, definitions, "");186        next_rowid += 1;187188        for (definition.indexes, 0..) |index_definition, index_offset| {189            var fields_buffer: [relation_mod.max_index_fields * field_bytes]u8 = undefined;190            var collations_buffer: [relation_mod.max_index_fields]u8 = undefined;191            const fields = try encodeFields(&fields_buffer, index_definition.fields);192            const collations = try encodeCollations(&collations_buffer, index_definition.fields.len, index_definition.columns);193            try putCatalogRow(194                &schema,195                &write,196                next_rowid,197                index_kind,198                index_definition.name,199                definition.name,200                index_roots[index_offset].root_page,201                index_roots[index_offset].identity_page,202                fields,203                collations,204            );205            next_rowid += 1;206        }207208        return .{209            .storage = try write.commit(options),210            .schema = next_schema,211        };212    }213214    pub fn createIndex(self: *const Catalog, allocator: Allocator, table_name: []const u8, definition: IndexDefinition, options: file.CommitOptions) Error!Commit {215        const phase = trace.scope("catalog.create_index");216        defer phase.end();217218        if (definition.name.len == 0) return error.CatalogCorrupt;219        if (definition.fields.len == 0 or definition.fields.len > relation_mod.max_index_fields) return error.TooManyIndexFields;220        if (definition.columns.len > definition.fields.len) return error.CatalogCorrupt;221222        var roots: [space_mod.max_roots]space_mod.RootSpec = undefined;223        var root_count: usize = 0;224        try addRoot(&roots, &root_count, .{ .root_page = self.root_page });225226        var table_root: ?u32 = null;227        var table_definitions: [max_columns]ColumnDefinition = undefined;228        var table_names: [max_column_name_bytes]u8 = undefined;229        var table_defaults: [max_column_default_bytes]u8 = undefined;230        var table_definition_count: usize = 0;231        var table_index_count: usize = 0;232        var old_stats: std.ArrayList(i64) = .empty;233        defer old_stats.deinit(allocator);234        var state = CatalogState{};235        var scan: table.Scan = undefined;236        try self.schema.scan(&scan, allocator, null, null);237        defer scan.deinit();238        while (try scan.next()) |entry| {239            var scratch = CatalogScratch{};240            switch (try state.record(entry, &scratch)) {241                .schema => {},242                .object => |object| switch (object.kind) {243                    .relation => {244                        if (std.mem.eql(u8, object.name, definition.name)) return error.ObjectExists;245                        try addRoot(&roots, &root_count, .{ .root_page = object.root_page, .identity_page = object.identity_page });246                        if (std.mem.eql(u8, object.name, table_name)) {247                            if (table_root != null) return error.CatalogCorrupt;248                            table_root = object.root_page;249                            table_definition_count = object.definitions.len;250                            _ = try copyDefinitions(&table_definitions, &table_names, &table_defaults, object.definitions);251                        }252                    },253                    .index => {254                        if (std.mem.eql(u8, object.name, definition.name)) return error.ObjectExists;255                        try addRoot(&roots, &root_count, .{ .root_page = object.root_page, .identity_page = object.identity_page });256                        if (std.mem.eql(u8, object.table_name, table_name)) table_index_count += 1;257                    },258                    .schema => unreachable,259                    .stats => unreachable,260                },261                .stats => |stats| {262                    if (std.mem.eql(u8, stats.table_name, table_name)) try old_stats.append(allocator, entry.rowid);263                },264            }265        }266        const next_schema = try bumpSchemaVersion(try state.schemaOrDefault());267        const root_page = table_root orelse return error.RelationNotFound;268        if (table_index_count >= relation_mod.max_indexes) return error.TooManyIndexes;269        for (definition.fields) |field| {270            if (field >= table_definition_count) return error.ColumnOutOfBounds;271        }272273        const space = try space_mod.Space.open(self.database, .{274            .meta_page = self.meta_page,275            .roots = roots[0..root_count],276        });277        var table_rows = try space.rowidTable(root_page);278        var schema = try space.rowidTable(self.root_page);279        var write = try space.beginWrite();280        defer write.deinit();281282        const index_root = try allocateCatalogRoot(&write, &roots, &root_count);283        const index_space = try space_mod.Space.open(self.database, .{284            .meta_page = self.meta_page,285            .roots = roots[0..root_count],286        });287        var relation_index = try index_space.index(index_root.root_page, definition.columns);288        var table_scan: table.Scan = undefined;289        try table_rows.scan(&table_scan, allocator, null, null);290        defer table_scan.deinit();291        while (try table_scan.next()) |entry| {292            const view = try entry.view();293            var projected: [relation_mod.max_index_fields]row.Value = undefined;294            try relation_index.putIn(&write, entry.rowid, try view.project(definition.fields, &projected));295        }296297        for (old_stats.items) |rowid| try schema.deleteIn(&write, rowid);298        try putSchemaRow(&schema, &write, next_schema);299300        var fields_buffer: [relation_mod.max_index_fields * field_bytes]u8 = undefined;301        var collations_buffer: [relation_mod.max_index_fields]u8 = undefined;302        const fields = try encodeFields(&fields_buffer, definition.fields);303        const collations = try encodeCollations(&collations_buffer, definition.fields.len, definition.columns);304        try putCatalogRow(305            &schema,306            &write,307            @max(state.max_rowid + 1, first_object_rowid),308            index_kind,309            definition.name,310            table_name,311            index_root.root_page,312            index_root.identity_page,313            fields,314            collations,315        );316317        return .{318            .storage = try write.commit(options),319            .schema = next_schema,320        };321    }322323    pub fn dropRelation(self: *const Catalog, allocator: Allocator, name: []const u8, options: file.CommitOptions) Error!Commit {324        const phase = trace.scope("catalog.drop_relation");325        defer phase.end();326327        var roots: [space_mod.max_roots]space_mod.RootSpec = undefined;328        var root_count: usize = 0;329        try addRoot(&roots, &root_count, .{ .root_page = self.root_page });330331        var rowids: std.ArrayList(i64) = .empty;332        defer rowids.deinit(allocator);333        var found_relation = false;334        var state = CatalogState{};335336        var scan: table.Scan = undefined;337        try self.schema.scan(&scan, allocator, null, null);338        defer scan.deinit();339        while (try scan.next()) |entry| {340            var scratch = CatalogScratch{};341            switch (try state.record(entry, &scratch)) {342                .schema => {},343                .object => |object| switch (object.kind) {344                    .relation => {345                        try addRoot(&roots, &root_count, .{ .root_page = object.root_page, .identity_page = object.identity_page });346                        if (std.mem.eql(u8, object.name, name)) {347                            if (found_relation) return error.CatalogCorrupt;348                            found_relation = true;349                            try rowids.append(allocator, entry.rowid);350                        }351                    },352                    .index => {353                        try addRoot(&roots, &root_count, .{ .root_page = object.root_page, .identity_page = object.identity_page });354                        if (std.mem.eql(u8, object.table_name, name)) try rowids.append(allocator, entry.rowid);355                    },356                    .schema => unreachable,357                    .stats => unreachable,358                },359                .stats => |stats| {360                    if (std.mem.eql(u8, stats.table_name, name)) try rowids.append(allocator, entry.rowid);361                },362            }363        }364        const next_schema = try bumpSchemaVersion(try state.schemaOrDefault());365        if (!found_relation) return error.RelationNotFound;366367        const space = try space_mod.Space.open(self.database, .{368            .meta_page = self.meta_page,369            .roots = roots[0..root_count],370        });371        var schema = try space.rowidTable(self.root_page);372        var write = try space.beginWrite();373        defer write.deinit();374375        for (rowids.items) |rowid| try schema.deleteIn(&write, rowid);376        try putSchemaRow(&schema, &write, next_schema);377378        return .{379            .storage = try write.commit(options),380            .schema = next_schema,381        };382    }383384    pub fn openRelation(385        self: *const Catalog,386        allocator: Allocator,387        name: []const u8,388    ) Error!RelationHandle {389        return try openRelationFrom(390            RelationHandle,391            space_mod.Space,392            relation_mod.Relation,393            self.database,394            &self.schema,395            self.meta_page,396            self.root_page,397            allocator,398            name,399        );400    }401402    pub fn relationNames(self: *const Catalog, allocator: Allocator) Error!RelationNames {403        return try readRelationNames(&self.schema, allocator);404    }405406    pub fn analyzeRelation(self: *const Catalog, allocator: Allocator, name: []const u8, options: file.CommitOptions) Error!Commit {407        const phase = trace.scope("catalog.analyze_relation");408        defer phase.end();409410        var roots: [space_mod.max_roots]space_mod.RootSpec = undefined;411        var root_count: usize = 0;412        try addRoot(&roots, &root_count, .{ .root_page = self.root_page });413414        var table_root: ?u32 = null;415        var indexes: std.ArrayList(AnalyzeIndex) = .empty;416        defer indexes.deinit(allocator);417        defer freeAnalyzeIndexes(allocator, indexes.items);418        var old_stats: std.ArrayList(i64) = .empty;419        defer old_stats.deinit(allocator);420        var state = CatalogState{};421422        var scan: table.Scan = undefined;423        try self.schema.scan(&scan, allocator, null, null);424        defer scan.deinit();425        while (try scan.next()) |entry| {426            var scratch = CatalogScratch{};427            switch (try state.record(entry, &scratch)) {428                .schema => {},429                .object => |object| switch (object.kind) {430                    .relation => {431                        try addRoot(&roots, &root_count, .{ .root_page = object.root_page, .identity_page = object.identity_page });432                        if (std.mem.eql(u8, object.name, name)) table_root = object.root_page;433                    },434                    .index => {435                        try addRoot(&roots, &root_count, .{ .root_page = object.root_page, .identity_page = object.identity_page });436                        if (std.mem.eql(u8, object.table_name, name)) {437                            if (indexes.items.len >= relation_mod.max_indexes) return error.TooManyIndexes;438                            const owned_name = try allocator.dupe(u8, object.name);439                            var analyzed_index = AnalyzeIndex{440                                .name = owned_name,441                                .root_page = object.root_page,442                                .field_count = object.fields.len,443                            };444                            @memcpy(analyzed_index.fields[0..object.fields.len], object.fields);445                            @memcpy(analyzed_index.columns[0..object.columns.len], object.columns);446                            indexes.append(allocator, analyzed_index) catch |err| {447                                allocator.free(owned_name);448                                return err;449                            };450                        }451                    },452                    .schema => unreachable,453                    .stats => unreachable,454                },455                .stats => |stats| {456                    if (std.mem.eql(u8, stats.table_name, name)) try old_stats.append(allocator, entry.rowid);457                },458            }459        }460        const current_schema = try state.schemaOrDefault();461        const root_page = table_root orelse return error.RelationNotFound;462463        const space = try space_mod.Space.open(self.database, .{464            .meta_page = self.meta_page,465            .roots = roots[0..root_count],466        });467        var schema = try space.rowidTable(self.root_page);468        var relation_table = try space.rowidTable(root_page);469        const table_summary = try relation_table.summarize();470        var index_summaries: [relation_mod.max_indexes]tree.Summary = undefined;471        for (indexes.items, 0..) |index_object, index_offset| {472            var relation_index = try space.index(index_object.root_page, index_object.indexColumns());473            index_summaries[index_offset] = try relation_index.summarize();474            indexes.items[index_offset].distribution_blob = try analyzeIndexDistribution(allocator, &relation_index);475        }476477        var write = try space.beginWrite();478        defer write.deinit();479        for (old_stats.items) |rowid| try schema.deleteIn(&write, rowid);480481        var summary_buffer: [summary_blob_bytes]u8 = undefined;482        var next_rowid = @max(state.max_rowid + 1, first_object_rowid);483        try putCatalogRow(484            &schema,485            &write,486            next_rowid,487            stats_kind,488            name,489            name,490            root_page,491            0,492            try encodeSummary(&summary_buffer, table_summary),493            "",494        );495        next_rowid += 1;496497        for (indexes.items, 0..) |index_object, index_offset| {498            try putCatalogRow(499                &schema,500                &write,501                next_rowid,502                stats_kind,503                index_object.name,504                name,505                index_object.root_page,506                0,507                try encodeSummary(&summary_buffer, index_summaries[index_offset]),508                index_object.distribution_blob,509            );510            next_rowid += 1;511        }512513        return .{514            .storage = try write.commit(options),515            .schema = current_schema,516        };517    }518519    pub fn clearRelationStats(self: *const Catalog, allocator: Allocator, name: []const u8, options: file.CommitOptions) Error!?Commit {520        const phase = trace.scope("catalog.clear_relation_stats");521        defer phase.end();522523        var roots: [space_mod.max_roots]space_mod.RootSpec = undefined;524        var root_count: usize = 0;525        try addRoot(&roots, &root_count, .{ .root_page = self.root_page });526527        var old_stats: std.ArrayList(i64) = .empty;528        defer old_stats.deinit(allocator);529        var found_relation = false;530        var state = CatalogState{};531532        var scan: table.Scan = undefined;533        try self.schema.scan(&scan, allocator, null, null);534        defer scan.deinit();535        while (try scan.next()) |entry| {536            var scratch = CatalogScratch{};537            switch (try state.record(entry, &scratch)) {538                .schema => {},539                .object => |object| switch (object.kind) {540                    .relation => {541                        try addRoot(&roots, &root_count, .{ .root_page = object.root_page, .identity_page = object.identity_page });542                        if (std.mem.eql(u8, object.name, name)) {543                            if (found_relation) return error.CatalogCorrupt;544                            found_relation = true;545                        }546                    },547                    .index => try addRoot(&roots, &root_count, .{ .root_page = object.root_page, .identity_page = object.identity_page }),548                    .schema => unreachable,549                    .stats => unreachable,550                },551                .stats => |stats| {552                    if (std.mem.eql(u8, stats.table_name, name)) try old_stats.append(allocator, entry.rowid);553                },554            }555        }556        const current_schema = try state.schemaOrDefault();557        if (!found_relation) return error.RelationNotFound;558        if (old_stats.items.len == 0) return null;559560        const space = try space_mod.Space.open(self.database, .{561            .meta_page = self.meta_page,562            .roots = roots[0..root_count],563        });564        var schema = try space.rowidTable(self.root_page);565        var write = try space.beginWrite();566        defer write.deinit();567568        for (old_stats.items) |rowid| try schema.deleteIn(&write, rowid);569570        return .{571            .storage = try write.commit(options),572            .schema = current_schema,573        };574    }575576    pub fn relationStats(self: *const Catalog, allocator: Allocator, name: []const u8) Error!?RelationStats {577        return try readRelationStats(&self.schema, allocator, name);578    }579580    /// Returns what `schemaState`, `openRelation` and `relationStats` return581    /// for `name`, read in one catalog pass over one snapshot.582    pub fn readRelation(583        self: *const Catalog,584        allocator: Allocator,585        name: []const u8,586    ) Error!RelationState {587        return try readRelationFrom(588            RelationHandle,589            space_mod.Space,590            relation_mod.Relation,591            self.database,592            &self.schema,593            self.meta_page,594            self.root_page,595            allocator,596            name,597        );598    }599};

1pub const Catalog = catalog.Catalog;