tiny.smg.storage.names

1const std = @import("std");2const sql = @import("sql");3const sys = @import("sys");4const smg = @import("../root.zig");56const storage = smg.storage;7const fs_io = std.Options.debug_io;89pub const file_name = "names.bin";10pub const temp_file_name = "names.bin.tmp";1112const magic = "tiny.smg.names/v1\n";13const digest_bytes = std.crypto.hash.sha2.Sha256.digest_length;14const read_buffer_bytes = 64 * 1024;15const write_buffer_bytes = 64 * 1024;16const max_cache_bytes: u64 = 512 * 1024 * 1024;17const header_bytes = magic.len + @sizeOf(sql.Hash) + @sizeOf(u64);18const minimum_file_bytes = header_bytes + digest_bytes;1920pub fn matchesHead(21    allocator: std.mem.Allocator,22    root: []const u8,23    expected: sql.Hash,24) std.mem.Allocator.Error!bool {25    const path = try cachePath(allocator, root, file_name);26    defer allocator.free(path);27    var file = std.Io.Dir.openFileAbsolute(fs_io, path, .{}) catch return false;28    defer file.close(fs_io);29    const stat = file.stat(fs_io) catch return false;30    if (stat.kind != .file or stat.size < minimum_file_bytes) return false;31    if (stat.size > max_cache_bytes) return false;32    var header: [header_bytes]u8 = undefined;33    const read = file.readPositionalAll(fs_io, &header, 0) catch return false;34    if (read != header.len) return false;35    if (!std.mem.eql(u8, header[0..magic.len], magic)) return false;36    return std.mem.eql(37        u8,38        header[magic.len .. magic.len + @sizeOf(sql.Hash)],39        expected[0..],40    );41}4243pub fn scan(44    allocator: std.mem.Allocator,45    root: []const u8,46    expected: sql.Hash,47    visitor: anytype,48) !void {49    const path = try cachePath(allocator, root, file_name);50    defer allocator.free(path);51    var file = try std.Io.Dir.openFileAbsolute(fs_io, path, .{});52    defer file.close(fs_io);53    const stat = try file.stat(fs_io);54    if (stat.kind != .file or stat.size < minimum_file_bytes) {55        return error.InvalidNameProjection;56    }57    if (stat.size > max_cache_bytes) return error.InvalidNameProjection;58    var read_buffer: [read_buffer_bytes]u8 = undefined;59    var file_reader = file.reader(fs_io, &read_buffer);60    const reader = &file_reader.interface;61    var stored_magic: [magic.len]u8 = undefined;62    try readExact(reader, &stored_magic);63    if (!std.mem.eql(u8, &stored_magic, magic)) return error.InvalidNameProjection;64    var stored_head: sql.Hash = undefined;65    try readExact(reader, &stored_head);66    if (!std.mem.eql(u8, &stored_head, &expected)) return error.StaleNameProjection;67    var count_bytes: [@sizeOf(u64)]u8 = undefined;68    try readExact(reader, &count_bytes);69    const count = std.mem.readInt(u64, &count_bytes, .big);70    const entry_bytes = stat.size - minimum_file_bytes;71    if (count > entry_bytes / @sizeOf(u32)) return error.InvalidNameProjection;7273    var hasher = std.crypto.hash.sha2.Sha256.init(.{});74    var name_buffer: [sql.page.size]u8 = undefined;75    var index: u64 = 0;76    while (index < count) : (index += 1) {77        var length_bytes: [@sizeOf(u32)]u8 = undefined;78        try readExact(reader, &length_bytes);79        hasher.update(&length_bytes);80        const length: usize = @intCast(std.mem.readInt(u32, &length_bytes, .big));81        if (length == 0 or length > name_buffer.len) return error.InvalidNameProjection;82        const name = name_buffer[0..length];83        try readExact(reader, name);84        hasher.update(name);85        try visitor.visit(name);86    }87    var stored_digest: [digest_bytes]u8 = undefined;88    try readExact(reader, &stored_digest);89    var computed_digest: [digest_bytes]u8 = undefined;90    hasher.final(&computed_digest);91    if (!std.mem.eql(u8, &stored_digest, &computed_digest)) {92        return error.InvalidNameProjection;93    }94    _ = reader.takeByte() catch |err| switch (err) {95        error.EndOfStream => return,96        else => return error.InvalidNameProjection,97    };98    return error.InvalidNameProjection;99}100101pub fn writeForHead(102    allocator: std.mem.Allocator,103    root: []const u8,104    database: *storage.database.Database,105    head: sql.Hash,106) !void {107    const temporary = try cachePath(allocator, root, temp_file_name);108    defer allocator.free(temporary);109    const destination = try cachePath(allocator, root, file_name);110    defer allocator.free(destination);111    errdefer std.Io.Dir.deleteFileAbsolute(fs_io, temporary) catch {};112    {113        var file = try std.Io.Dir.createFileAbsolute(fs_io, temporary, .{ .truncate = true });114        defer file.close(fs_io);115        var write_buffer: [write_buffer_bytes]u8 = undefined;116        var file_writer = file.writer(fs_io, &write_buffer);117        const writer = &file_writer.interface;118        try writer.writeAll(magic);119        try writer.writeAll(&head);120        var handle = try database.connection.catalog.openRelation(121            database.allocator,122            storage.rows.nodes_relation,123        );124        defer handle.deinit();125        const count = try handle.relation.table.count();126        var count_bytes: [@sizeOf(u64)]u8 = undefined;127        std.mem.writeInt(u64, &count_bytes, @intCast(count), .big);128        try writer.writeAll(&count_bytes);129        const scan_index = try nodeNameIndexSlot(&handle);130        var entries: sql.IndexScan = undefined;131        try handle.relation.indexScan(132            &entries,133            database.allocator,134            scan_index,135            null,136            null,137        );138        defer entries.deinit();139        var values: [1]sql.row.Value = undefined;140        var key_scratch: [sql.page.size]u8 = undefined;141        var hasher = std.crypto.hash.sha2.Sha256.init(.{});142        var projected_bytes: u64 = minimum_file_bytes;143        var written: usize = 0;144        while (written < count) : (written += 1) {145            const entry = (try entries.next()) orelse return error.StorageIndexCorrupt;146            const name = try indexedName(&values, &key_scratch, entry.key);147            if (name.len == 0 or name.len > sql.page.size) return error.InvalidName;148            const entry_bytes: u64 = @sizeOf(u32) + @as(u64, @intCast(name.len));149            if (entry_bytes > max_cache_bytes - projected_bytes) {150                return error.NameProjectionTooLarge;151            }152            projected_bytes += entry_bytes;153            var length_bytes: [@sizeOf(u32)]u8 = undefined;154            std.mem.writeInt(u32, &length_bytes, @intCast(name.len), .big);155            try writer.writeAll(&length_bytes);156            try writer.writeAll(name);157            hasher.update(&length_bytes);158            hasher.update(name);159        }160        if (try entries.next() != null) return error.StorageIndexCorrupt;161        var digest: [digest_bytes]u8 = undefined;162        hasher.final(&digest);163        try writer.writeAll(&digest);164        try writer.flush();165        try file.sync(fs_io);166    }167    try sys.fs.rename(temporary, destination);168}169170pub fn indexedName(171    values: *[1]sql.row.Value,172    scratch: []u8,173    key_bytes: []const u8,174) ![]const u8 {175    const decoded = sql.key.decodeIndex(values, scratch, key_bytes) catch176        return error.StorageIndexCorrupt;177    if (decoded.values.len != 1) return error.StorageIndexCorrupt;178    return switch (decoded.values[0]) {179        .text => |name| name,180        else => error.StorageIndexCorrupt,181    };182}183184fn nodeNameIndexSlot(handle: anytype) !usize {185    for (handle.index_definitions, 0..) |definition, slot| {186        if (std.mem.eql(u8, definition.name, storage.rows.node_name_index)) {187            return slot;188        }189    }190    return error.StorageIndexMissing;191}192193fn readExact(reader: *std.Io.Reader, target: []u8) !void {194    reader.readSliceAll(target) catch return error.InvalidNameProjection;195}196197fn cachePath(198    allocator: std.mem.Allocator,199    root: []const u8,200    name: []const u8,201) std.mem.Allocator.Error![]const u8 {202    return try std.fs.path.join(203        allocator,204        &.{ root, storage.paths.smg_dir_name, name },205    );206}

1pub const names = @import("names.zig");