tiny.smg.storage.rows

1pub const ConceptDocumentPut = struct {2    rowid: i64,3    name: []const u8,4    document: []const u8,5};

1pub const ConceptDocumentRow = struct {2    rowid: i64,3    name: []const u8,4    document: []const u8,5};

1pub const EdgePut = struct {2    rowid: i64,3    edge: model.Edge,4};

1pub const EdgeRow = struct {2    rowid: i64,3    edge: model.Edge,4};

1pub const GraphEdits = struct {2    node_puts: []const NodePut = &.{},3    node_deletes: []const i64 = &.{},4    edge_puts: []const EdgePut = &.{},5    edge_deletes: []const i64 = &.{},6    concept_document_puts: []const ConceptDocumentPut = &.{},7    concept_document_deletes: []const i64 = &.{},89    pub fn isEmpty(self: GraphEdits) bool {10        return self.node_puts.len == 0 and self.node_deletes.len == 0 and11            self.edge_puts.len == 0 and self.edge_deletes.len == 0 and12            self.concept_document_puts.len == 0 and self.concept_document_deletes.len == 0;13    }14};

1pub const NodePut = struct {2    rowid: i64,3    node: model.Node,4};

1pub fn decodeEdgeRow(allocator: std.mem.Allocator, rowid: i64, bytes: []const u8) Error!types.EdgeRow {2    const view = try sql.RowView.init(bytes);3    var edge = model.Edge{4        .source = try columnText(allocator, view, 0),5        .target = &.{},6        .rel = &.{},7    };8    errdefer model.deinitEdge(&edge, allocator);9    edge.rel = try columnText(allocator, view, 1);10    edge.target = try columnText(allocator, view, 2);11    edge.metadata = try decodeMetadata(allocator, view, 3);12    return .{ .rowid = rowid, .edge = edge };13}

1pub fn decodeNodeRow(allocator: std.mem.Allocator, rowid: i64, bytes: []const u8) Error!types.NodeRow {2    const view = try sql.RowView.init(bytes);3    var node = model.Node{4        .name = try columnText(allocator, view, 0),5        .type = &.{},6    };7    errdefer model.deinitNode(&node, allocator);8    node.type = try columnText(allocator, view, 1);9    node.file = try columnOptionalText(allocator, view, 2);10    node.line = try columnOptionalInteger(view, 3);11    node.end_line = try columnOptionalInteger(view, 4);12    node.docstring = try columnOptionalText(allocator, view, 5);13    node.metadata = try decodeMetadata(allocator, view, 6);14    return .{ .rowid = rowid, .node = node };15}

1pub fn edgeRelView(bytes: []const u8) Error![]const u8 {2    const view = try sql.RowView.init(bytes);3    return try columnTextView(view, 1);4}

1pub fn edgeSourceView(bytes: []const u8) Error![]const u8 {2    const view = try sql.RowView.init(bytes);3    return try columnTextView(view, 0);4}

1pub fn edgeTargetView(bytes: []const u8) Error![]const u8 {2    const view = try sql.RowView.init(bytes);3    return try columnTextView(view, 2);4}

1pub fn freeConceptDocumentRowSlice(row_allocator: std.mem.Allocator, value_allocator: std.mem.Allocator, row_slice: []types.ConceptDocumentRow) void {2    for (row_slice) |row| {3        value_allocator.free(row.name);4        value_allocator.free(row.document);5    }6    if (row_slice.len != 0) row_allocator.free(row_slice);7}

1pub fn freeEdgeRowSlice(row_allocator: std.mem.Allocator, value_allocator: std.mem.Allocator, row_slice: []types.EdgeRow) void {2    for (row_slice) |*loaded| model.deinitEdge(&loaded.edge, value_allocator);3    if (row_slice.len != 0) row_allocator.free(row_slice);4}

1pub fn freeNodeRowSlice(row_allocator: std.mem.Allocator, value_allocator: std.mem.Allocator, row_slice: []types.NodeRow) void {2    for (row_slice) |*loaded| model.deinitNode(&loaded.node, value_allocator);3    if (row_slice.len != 0) row_allocator.free(row_slice);4}

1pub fn nodeDocstringView(bytes: []const u8) Error!?[]const u8 {2    const view = try sql.RowView.init(bytes);3    return try columnOptionalTextView(view, 5);4}

1pub fn nodeNameView(bytes: []const u8) Error![]const u8 {2    const view = try sql.RowView.init(bytes);3    return try columnTextView(view, 0);4}

1pub fn nodeTypeView(bytes: []const u8) Error![]const u8 {2    const view = try sql.RowView.init(bytes);3    return try columnTextView(view, 1);4}

1pub fn scanConceptDocumentRows(2    opened_catalog: anytype,3    scratch_allocator: std.mem.Allocator,4    row_allocator: std.mem.Allocator,5    value_allocator: std.mem.Allocator,6) Error![]types.ConceptDocumentRow {7    var handle = opened_catalog.openRelation(scratch_allocator, types.concept_documents_relation) catch |err| switch (err) {8        error.RelationNotFound => return &.{},9        else => return err,10    };11    defer handle.deinit();12    var scan: sql.TableScan = undefined;13    try handle.relation.scan(&scan, scratch_allocator, null, null);14    defer scan.deinit();15    const count = try handle.relation.table.count();16    var loaded: std.ArrayList(types.ConceptDocumentRow) = .empty;17    errdefer freeConceptDocumentRows(row_allocator, value_allocator, &loaded);18    try loaded.ensureTotalCapacityPrecise(row_allocator, count);19    while (try scan.next()) |entry| {20        const view = try sql.RowView.init(entry.bytes);21        const name = try columnText(value_allocator, view, 0);22        errdefer value_allocator.free(name);23        const document = try columnText(value_allocator, view, 1);24        if (loaded.items.len == count) {25            value_allocator.free(document);26            return error.MalformedRow;27        }28        loaded.appendAssumeCapacity(.{29            .rowid = entry.rowid,30            .name = name,31            .document = document,32        });33    }34    if (loaded.items.len != count) return error.MalformedRow;35    return try loaded.toOwnedSlice(row_allocator);36}

1pub fn scanEdgeRows(2    opened_catalog: anytype,3    scratch_allocator: std.mem.Allocator,4    row_allocator: std.mem.Allocator,5    value_allocator: std.mem.Allocator,6) Error![]types.EdgeRow {7    var handle = opened_catalog.openRelation(scratch_allocator, types.edges_relation) catch |err| switch (err) {8        error.RelationNotFound => return &.{},9        else => return err,10    };11    defer handle.deinit();12    var scan: sql.TableScan = undefined;13    try handle.relation.scan(&scan, scratch_allocator, null, null);14    defer scan.deinit();15    const count = try handle.relation.table.count();16    var loaded: std.ArrayList(types.EdgeRow) = .empty;17    errdefer freeEdgeRows(row_allocator, value_allocator, &loaded);18    try loaded.ensureTotalCapacityPrecise(row_allocator, count);19    while (try scan.next()) |entry| {20        const decoded = try decodeEdgeRow(value_allocator, entry.rowid, entry.bytes);21        if (loaded.items.len == count) {22            var rejected = decoded;23            model.deinitEdge(&rejected.edge, value_allocator);24            return error.MalformedRow;25        }26        loaded.appendAssumeCapacity(decoded);27    }28    if (loaded.items.len != count) return error.MalformedRow;29    return try loaded.toOwnedSlice(row_allocator);30}

1pub fn scanEdgeRowsInto(2    opened_catalog: anytype,3    scratch_allocator: std.mem.Allocator,4    value_allocator: std.mem.Allocator,5    out: []types.EdgeRow,6) Error!void {7    var handle = opened_catalog.openRelation(scratch_allocator, types.edges_relation) catch |err| switch (err) {8        error.RelationNotFound => if (out.len == 0) return else return error.MalformedRow,9        else => return err,10    };11    defer handle.deinit();12    var scan: sql.TableScan = undefined;13    try handle.relation.scan(&scan, scratch_allocator, null, null);14    defer scan.deinit();15    var filled: usize = 0;16    errdefer for (out[0..filled]) |*loaded| model.deinitEdge(&loaded.edge, value_allocator);17    while (try scan.next()) |entry| {18        if (filled == out.len) return error.MalformedRow;19        out[filled] = try decodeEdgeRow(value_allocator, entry.rowid, entry.bytes);20        filled += 1;21    }22    if (filled != out.len) return error.MalformedRow;23}

1pub fn scanNodeRows(2    opened_catalog: anytype,3    scratch_allocator: std.mem.Allocator,4    row_allocator: std.mem.Allocator,5    value_allocator: std.mem.Allocator,6) Error![]types.NodeRow {7    var handle = opened_catalog.openRelation(scratch_allocator, types.nodes_relation) catch |err| switch (err) {8        error.RelationNotFound => return &.{},9        else => return err,10    };11    defer handle.deinit();12    var scan: sql.TableScan = undefined;13    try handle.relation.scan(&scan, scratch_allocator, null, null);14    defer scan.deinit();15    const count = try handle.relation.table.count();16    var loaded: std.ArrayList(types.NodeRow) = .empty;17    errdefer freeNodeRows(row_allocator, value_allocator, &loaded);18    try loaded.ensureTotalCapacityPrecise(row_allocator, count);19    while (try scan.next()) |entry| {20        const decoded = try decodeNodeRow(value_allocator, entry.rowid, entry.bytes);21        if (loaded.items.len == count) {22            var rejected = decoded;23            model.deinitNode(&rejected.node, value_allocator);24            return error.MalformedRow;25        }26        loaded.appendAssumeCapacity(decoded);27    }28    if (loaded.items.len != count) return error.MalformedRow;29    return try loaded.toOwnedSlice(row_allocator);30}

1pub fn scanNodeRowsInto(2    opened_catalog: anytype,3    scratch_allocator: std.mem.Allocator,4    value_allocator: std.mem.Allocator,5    out: []types.NodeRow,6) Error!void {7    var handle = opened_catalog.openRelation(scratch_allocator, types.nodes_relation) catch |err| switch (err) {8        error.RelationNotFound => if (out.len == 0) return else return error.MalformedRow,9        else => return err,10    };11    defer handle.deinit();12    var scan: sql.TableScan = undefined;13    try handle.relation.scan(&scan, scratch_allocator, null, null);14    defer scan.deinit();15    var filled: usize = 0;16    errdefer for (out[0..filled]) |*loaded| model.deinitNode(&loaded.node, value_allocator);17    while (try scan.next()) |entry| {18        if (filled == out.len) return error.MalformedRow;19        out[filled] = try decodeNodeRow(value_allocator, entry.rowid, entry.bytes);20        filled += 1;21    }22    if (filled != out.len) return error.MalformedRow;23}

1pub const Error = error{ MalformedRow, InvalidMetadata, OutOfMemory } || sql.statement.Error || sql.catalog.Error;

1pub const concept_document_columns = "name, document, INDEX " ++ concept_name_index ++ " (name)";

1pub const concept_documents_relation = "concepts";

1pub const concept_name_index = "concepts_name";

1pub const edge_columns = "source, rel, target, metadata, INDEX " ++ edge_source_index ++ " (source), INDEX " ++ edge_target_index ++ " (target)";

1pub const edge_source_index = "edges_source";

1pub const edge_target_index = "edges_target";

1pub const edges_relation = "edges";

1pub const node_columns = "name, type, file, line, end_line, docstring, metadata, INDEX " ++ node_name_index ++ " (name)";

1pub const node_name_index = "nodes_name";

1pub const nodes_relation = "nodes";

1pub fn putConceptDocumentRow(session: *sql.RelationSession, put: types.ConceptDocumentPut) Error!void {2    try session.put(put.rowid, &.{3        .{ .text = put.name },4        .{ .text = put.document },5    });6}

1pub fn putEdgeRow(allocator: std.mem.Allocator, session: *sql.RelationSession, rowid: i64, edge: model.Edge) Error!void {2    const metadata = try renderMetadata(allocator, edge.metadata);3    defer if (metadata) |rendered| allocator.free(rendered);4    const values = [_]sql.row.Value{5        .{ .text = edge.source },6        .{ .text = edge.rel },7        .{ .text = edge.target },8        optionalText(metadata),9    };10    try session.put(rowid, &values);11}

1pub fn putNodeRow(allocator: std.mem.Allocator, session: *sql.RelationSession, rowid: i64, node: model.Node) Error!void {2    const metadata = try renderMetadata(allocator, node.metadata);3    defer if (metadata) |rendered| allocator.free(rendered);4    const values = [_]sql.row.Value{5        .{ .text = node.name },6        .{ .text = node.type },7        optionalText(node.file),8        optionalInteger(node.line),9        optionalInteger(node.end_line),10        optionalText(node.docstring),11        optionalText(metadata),12    };13    try session.put(rowid, &values);14}

1pub const rows = @import("rows/root.zig");

1const read = @import("read.zig");2const types = @import("types.zig");3const write = @import("write.zig");45pub const Error = types.Error;6pub const node_columns = types.node_columns;7pub const edge_columns = types.edge_columns;8pub const concept_document_columns = types.concept_document_columns;9pub const nodes_relation = types.nodes_relation;10pub const edges_relation = types.edges_relation;11pub const concept_documents_relation = types.concept_documents_relation;12pub const node_name_index = types.node_name_index;13pub const edge_source_index = types.edge_source_index;14pub const edge_target_index = types.edge_target_index;15pub const concept_name_index = types.concept_name_index;1617pub const NodeRow = types.NodeRow;18pub const EdgeRow = types.EdgeRow;19pub const ConceptDocumentRow = types.ConceptDocumentRow;20pub const NodePut = types.NodePut;21pub const EdgePut = types.EdgePut;22pub const ConceptDocumentPut = types.ConceptDocumentPut;23pub const GraphEdits = types.GraphEdits;2425pub const freeNodeRowSlice = read.freeNodeRowSlice;26pub const freeEdgeRowSlice = read.freeEdgeRowSlice;27pub const freeConceptDocumentRowSlice = read.freeConceptDocumentRowSlice;28pub const scanNodeRows = read.scanNodeRows;29pub const scanEdgeRows = read.scanEdgeRows;30pub const scanConceptDocumentRows = read.scanConceptDocumentRows;31pub const scanNodeRowsInto = read.scanNodeRowsInto;32pub const scanEdgeRowsInto = read.scanEdgeRowsInto;33pub const decodeNodeRow = read.decodeNodeRow;34pub const decodeEdgeRow = read.decodeEdgeRow;35pub const nodeNameView = read.nodeNameView;36pub const nodeTypeView = read.nodeTypeView;37pub const nodeDocstringView = read.nodeDocstringView;38pub const edgeSourceView = read.edgeSourceView;39pub const edgeRelView = read.edgeRelView;40pub const edgeTargetView = read.edgeTargetView;4142pub const putNodeRow = write.putNodeRow;43pub const putEdgeRow = write.putEdgeRow;44pub const putConceptDocumentRow = write.putConceptDocumentRow;