datastore: typed value retrieval

packages/datastore/src/root.zig

@@ -165,12 +165,20 @@ pub const Database = struct {
         return row_id;
     }
 
-    pub fn getValue(self: *Database, table_id: TableId, column_id: ColumnId, row_id: RowId) !TaggedValue {
+    pub fn getTaggedValue(self: *Database, table_id: TableId, column_id: ColumnId, row_id: RowId) !TaggedValue {
         const table = self.tables.getPtr(table_id) orelse return error.TableNotFound;
         const column = table.columns.getPtr(column_id) orelse return error.ColumnNotFound;
 
         if (row_id.toInt() >= table.next_row_id.toInt()) return error.RowIdNotFound;
-        return column.get(row_id);
+        return column.getTagged(row_id);
+    }
+
+    pub fn getValue(self: *Database, comptime T: type, table_id: TableId, column_id: ColumnId, row_id: RowId) !TaggedValue {
+        const table = self.tables.getPtr(table_id) orelse return error.TableNotFound;
+        const column = table.columns.getPtr(column_id) orelse return error.ColumnNotFound;
+
+        if (row_id.toInt() >= table.next_row_id.toInt()) return error.RowIdNotFound;
+        return column.get(T, row_id);
     }
 };
 
@@ -248,7 +256,7 @@ pub const Column = struct {
         self.* = undefined;
     }
 
-    pub fn get(self: *Column, row_id: RowId) TaggedValue {
+    pub fn getTagged(self: *Column, row_id: RowId) TaggedValue {
         const values_per_page = self.type.valuesPerPage(page_size);
 
         const page_index = @as(usize, row_id.toInt() / values_per_page);
@@ -294,7 +302,7 @@ pub const Column = struct {
         };
     }
 
-    pub fn getBool(self: *Column, row_id: RowId) !bool {
+    pub fn get(self: *Column, comptime T: type, row_id: RowId) !T {
         const values_per_page = self.type.valuesPerPage(page_size);
 
         const page_index = @as(usize, row_id.toInt() / values_per_page);
@@ -302,10 +310,114 @@ pub const Column = struct {
 
         const page = &self.pages.items[page_index];
 
-        return switch (self.type) {
+        return switch (T) {
+            bool => switch (self.type) {
                 .bool => page.get(bool, value_index),
                 .bit => page.getBit(value_index),
                 else => error.TypeError,
+            },
+            u8 => switch (self.type) {
+                .u8 => page.get(u8, value_index),
+                else => error.TypeError,
+            },
+            u16 => switch (self.type) {
+                .u16 => page.get(u16, value_index),
+                else => error.TypeError,
+            },
+            u32 => switch (self.type) {
+                .u32 => page.get(u32, value_index),
+                else => error.TypeError,
+            },
+            u64 => switch (self.type) {
+                .u64 => page.get(u64, value_index),
+                else => error.TypeError,
+            },
+            i8 => switch (self.type) {
+                .i8 => page.get(i8, value_index),
+                else => error.TypeError,
+            },
+            i16 => switch (self.type) {
+                .i16 => page.get(i16, value_index),
+                else => error.TypeError,
+            },
+            i32 => switch (self.type) {
+                .i32 => page.get(i32, value_index),
+                else => error.TypeError,
+            },
+            i64 => switch (self.type) {
+                .i64 => page.get(i64, value_index),
+                else => error.TypeError,
+            },
+            f32 => switch (self.type) {
+                .f32 => page.get(f32, value_index),
+                else => error.TypeError,
+            },
+            f64 => switch (self.type) {
+                .f64 => page.get(f64, value_index),
+                else => error.TypeError,
+            },
+            vm.Color => switch (self.type) {
+                .color => page.get(vm.Color, value_index),
+                else => error.TypeError,
+            },
+            vm.ColorHdr => switch (self.type) {
+                .color_hdr => page.get(vm.ColorHdr, value_index),
+                else => error.TypeError,
+            },
+            vm.Matrix3x2 => switch (self.type) {
+                .mat3x2 => page.getClustered(vm.Matrix3x2, 8, value_index),
+                else => error.TypeError,
+            },
+            vm.Matrix4x4 => switch (self.type) {
+                .mat4x4 => page.getClustered(vm.Matrix4x4, 8, value_index),
+                else => error.TypeError,
+            },
+            vm.Complex => switch (self.type) {
+                .complex => page.getClustered(vm.Complex, 8, value_index),
+                else => error.TypeError,
+            },
+            vm.Quaternion => switch (self.type) {
+                .quaternion => page.getClustered(vm.Quaternion, 8, value_index),
+                else => error.TypeError,
+            },
+            vm.Vector2 => switch (self.type) {
+                .vec2 => page.getClustered(vm.Vector2, 8, value_index),
+                else => error.TypeError,
+            },
+            vm.Vector2Int => switch (self.type) {
+                .vec2i => page.getClustered(vm.Vector2Int, 8, value_index),
+                else => error.TypeError,
+            },
+            vm.Vector3 => switch (self.type) {
+                .vec3 => page.getClustered(vm.Vector3, 8, value_index),
+                else => error.TypeError,
+            },
+            vm.Vector3Int => switch (self.type) {
+                .vec3i => page.getClustered(vm.Vector3Int, 8, value_index),
+                else => error.TypeError,
+            },
+            vm.Vector4 => switch (self.type) {
+                .vec4 => page.getClustered(vm.Vector4, 8, value_index),
+                else => error.TypeError,
+            },
+            vm.Vector4Int => switch (self.type) {
+                .vec4i => page.getClustered(vm.Vector4Int, 8, value_index),
+                else => error.TypeError,
+            },
+            []const u8 => switch (self.type) {
+                .str8 => page.getPtr(FixedString(u8, 8), value_index).slice(),
+                .str16 => page.getPtr(FixedString(u8, 16), value_index).slice(),
+                .str32 => page.getPtr(FixedString(u8, 32), value_index).slice(),
+                .str64 => page.getPtr(FixedString(u8, 64), value_index).slice(),
+                .str128 => page.getPtr(FixedString(u8, 128), value_index).slice(),
+                .str256 => page.getPtr(FixedString(u8, 256), value_index).slice(),
+                .str512 => page.getPtr(FixedString(u16, 512), value_index).slice(),
+                .str1k => page.getPtr(FixedString(u16, 1024), value_index).slice(),
+                .str2k => page.getPtr(FixedString(u16, 2048), value_index).slice(),
+                .str4k => page.getPtr(FixedString(u16, 4096), value_index).slice(),
+                else => error.TypeError,
+            },
+            else => @compileError("Type " ++ @typeName(T) ++ " not supported."),
         };
     }
 
@@ -612,15 +724,15 @@ test {
         },
     });
 
-    const admin_username = try db.getValue(table_ids.users, column_ids.username, admin_id);
+    const admin_username = try db.getValue([]const u8, table_ids.users, column_ids.username, admin_id);
-    const admin_color = try db.getValue(table_ids.users, column_ids.color, admin_id);
+    const admin_color = try db.getValue(vm.Color, table_ids.users, column_ids.color, admin_id);
 
-    const user_username = try db.getValue(table_ids.users, column_ids.username, user_id);
+    const user_username = try db.getValue([]const u8, table_ids.users, column_ids.username, user_id);
-    const user_color = try db.getValue(table_ids.users, column_ids.color, user_id);
+    const user_color = try db.getValue(vm.Color, table_ids.users, column_ids.color, user_id);
 
-    try std.testing.expectEqualStrings("admin", admin_username.str);
+    try std.testing.expectEqualStrings("admin", admin_username);
-    try std.testing.expectEqual(vm.Color.red, admin_color.color);
+    try std.testing.expectEqual(vm.Color.red, admin_color);
 
-    try std.testing.expectEqualStrings("user", user_username.str);
+    try std.testing.expectEqualStrings("user", user_username);
-    try std.testing.expectEqual(vm.Color.blue, user_color.color);
+    try std.testing.expectEqual(vm.Color.blue, user_color);
 }