601 lines
19 KiB
Zig
601 lines
19 KiB
Zig
const std = @import("std");
|
|
const utils = @import("utils.zig");
|
|
const spacetime = @import("../spacetime.zig");
|
|
const console_log = spacetime.console_log;
|
|
const TableId = spacetime.TableId;
|
|
|
|
const SpacetimeValue = spacetime.SpacetimeValue;
|
|
const SpacetimeError = spacetime.SpacetimeError;
|
|
|
|
pub const Str = []const u8;
|
|
|
|
pub const SumTypeVariant = struct {
|
|
name: ?Str,
|
|
algebraic_type: AlgebraicType,
|
|
};
|
|
|
|
pub const SumType = struct {
|
|
variants: []const SumTypeVariant,
|
|
};
|
|
|
|
pub const ArrayType = struct {
|
|
elem_ty: []const AlgebraicType,
|
|
};
|
|
|
|
pub const AlgebraicType = union(enum) {
|
|
Ref: AlgebraicTypeRef,
|
|
Sum: SumType,
|
|
Product: ProductType,
|
|
Array: ArrayType,
|
|
String: void,
|
|
Bool: void,
|
|
I8: void,
|
|
U8: void,
|
|
I16: void,
|
|
U16: void,
|
|
I32: void,
|
|
U32: void,
|
|
I64: void,
|
|
U64: void,
|
|
I128: void,
|
|
U128: void,
|
|
I256: void,
|
|
U256: void,
|
|
F32: void,
|
|
F64: void,
|
|
};
|
|
|
|
pub const Typespace = struct {
|
|
types: []const AlgebraicType,
|
|
};
|
|
|
|
pub const RawIdentifier = Str;
|
|
|
|
pub const AlgebraicTypeRef = struct {
|
|
inner: u32,
|
|
};
|
|
|
|
pub const RawIndexAlgorithm = union(enum) {
|
|
BTree: []const u16,
|
|
Hash: []const u16,
|
|
Direct: u16,
|
|
};
|
|
|
|
pub const RawIndexDefV9 = struct {
|
|
name: ?Str,
|
|
accessor_name: ?Str,
|
|
algorithm: RawIndexAlgorithm,
|
|
};
|
|
|
|
pub const RawUniqueConstraintDataV9 = union(enum) {
|
|
Columns: []const u16,
|
|
};
|
|
|
|
pub const RawConstraintDataV9 = union(enum) {
|
|
unique: RawUniqueConstraintDataV9,
|
|
};
|
|
|
|
pub const RawConstraintDefV9 = struct {
|
|
name: ?Str,
|
|
data: RawConstraintDataV9
|
|
};
|
|
|
|
pub const RawSequenceDefV9 = struct {
|
|
name: ?Str,
|
|
column: u16,
|
|
start: ?i128,
|
|
min_value: ?i128,
|
|
max_value: ?i128,
|
|
increment: i128
|
|
};
|
|
|
|
pub const RawScheduleDefV9 = struct {
|
|
name: ?Str,
|
|
reducer_name: Str,
|
|
scheduled_at_column: u16
|
|
};
|
|
|
|
pub const TableType = enum {
|
|
System,
|
|
User,
|
|
};
|
|
|
|
pub const TableAccess = enum {
|
|
Public,
|
|
Private,
|
|
};
|
|
|
|
pub const RawTableDefV9 = struct {
|
|
name: RawIdentifier,
|
|
product_type_ref: AlgebraicTypeRef,
|
|
primary_key: []const u16,
|
|
indexes: []const RawIndexDefV9,
|
|
constraints: []const RawConstraintDefV9,
|
|
sequences: []const RawSequenceDefV9,
|
|
schedule: ?RawScheduleDefV9,
|
|
table_type: TableType,
|
|
table_access: TableAccess,
|
|
};
|
|
|
|
pub const ProductTypeElement = struct {
|
|
name: Str,
|
|
algebraic_type: AlgebraicType,
|
|
};
|
|
|
|
pub const ProductType = struct {
|
|
elements: []const ProductTypeElement,
|
|
};
|
|
|
|
pub const Lifecycle = enum {
|
|
Init,
|
|
OnConnect,
|
|
OnDisconnect,
|
|
None,
|
|
};
|
|
|
|
fn getUnionSize(data: anytype) usize {
|
|
return 1 + switch(data) {
|
|
inline else => |field| getDataSize(field),
|
|
};
|
|
}
|
|
|
|
fn getStructSize(data: anytype) usize {
|
|
var size: usize = 0;
|
|
inline for(std.meta.fields(@TypeOf(data))) |field| {
|
|
size += getDataSize(@field(data, field.name));
|
|
}
|
|
return size;
|
|
}
|
|
|
|
fn getDataSize(data: anytype) usize {
|
|
return switch(@TypeOf(data)) {
|
|
[]const u8 => 4 + data.len,
|
|
i8, u8, i16, u16, i32, u32,
|
|
i64, u64, i128, u128, i256, u256,
|
|
f32, f64 => |data_type| @sizeOf(data_type),
|
|
else => |data_type| switch(@typeInfo(data_type)) {
|
|
.@"struct" => getStructSize(data),
|
|
.@"union" => getUnionSize(data),
|
|
.@"enum" => @sizeOf(data_type),
|
|
.@"enum_literal" => @compileError("enum literals can't be supported without the type info"),
|
|
.@"optional" => 1 + getDataSize(data),
|
|
else => {
|
|
@compileLog(data_type);
|
|
@compileError("Unsupported type in getStructSize");
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
fn getUnionData(data: anytype, mem: *[]u8) void {
|
|
const tag: u8 = @intFromEnum(data);
|
|
appendValue(tag, mem);
|
|
switch(data) {
|
|
inline else => |field| {
|
|
appendValue(field, mem);
|
|
},
|
|
}
|
|
}
|
|
|
|
fn getStructData(data: anytype, mem: *[]u8) void {
|
|
const fields = std.meta.fields(@TypeOf(data));
|
|
inline for(fields) |field| {
|
|
appendValue(@field(data, field.name), mem);
|
|
}
|
|
}
|
|
|
|
fn appendValue(data: anytype, mem: *[]u8) void {
|
|
const data_type = @TypeOf(data);
|
|
switch(data_type) {
|
|
[]const u8 => {
|
|
std.mem.bytesAsValue(u32, mem.*[0..4]).* = data.len;
|
|
std.mem.copyForwards(u8, mem.*[4..], data);
|
|
mem.* = mem.*[4 + data.len ..];
|
|
},
|
|
i8, u8, i16, u16, i32, u32,
|
|
i64, u64, i128, u128, i256, u256,
|
|
f32, f64 => {
|
|
std.mem.bytesAsValue(data_type, mem.*[0..@sizeOf(data_type)]).* = data;
|
|
mem.* = mem.*[@sizeOf(data_type)..];
|
|
},
|
|
else => blk: {
|
|
if(@typeInfo(data_type) == .@"struct") {
|
|
getStructData(data, mem);
|
|
break :blk;
|
|
} else if(@typeInfo(data_type) == .@"union") {
|
|
getUnionData(data, mem);
|
|
break :blk;
|
|
} else if(@typeInfo(data_type) == .@"optional") {
|
|
mem.*[0] = @intFromBool(data == null);
|
|
mem.* = mem.*[1..];
|
|
if(data != null) {
|
|
appendValue(data.?, mem);
|
|
}
|
|
break :blk;
|
|
} else if(@typeInfo(data_type) == .@"enum") {
|
|
std.mem.bytesAsValue(data_type, mem.*[0..@sizeOf(data_type)]).* = data;
|
|
mem.* = mem.*[@sizeOf(data_type)..];
|
|
break :blk;
|
|
}
|
|
@compileLog(data_type);
|
|
@compileError("failed to append type!");
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn StructSerializer(struct_type: type) fn(std.mem.Allocator, struct_type) std.mem.Allocator.Error![]u8 {
|
|
return struct {
|
|
pub fn serialize(allocator: std.mem.Allocator, data: struct_type) ![]u8 {
|
|
const size: usize = switch(@typeInfo(@TypeOf(data))) {
|
|
.@"struct" => getStructSize(data),
|
|
else => @compileError("A table schema has to be a struct!"),
|
|
};
|
|
const mem = try allocator.alloc(u8, size);
|
|
var offset_mem = mem;
|
|
_ = getStructData(data, &offset_mem);
|
|
return mem;
|
|
}
|
|
}.serialize;
|
|
}
|
|
|
|
pub fn UnionDeserializer(union_type: type) fn(allocator: std.mem.Allocator, *[]const u8) std.mem.Allocator.Error!*union_type {
|
|
return struct {
|
|
pub fn deserialize(allocator: std.mem.Allocator, data: *[]const u8) std.mem.Allocator.Error!*union_type {
|
|
const ret = try allocator.create(union_type);
|
|
var offset_mem = data.*;
|
|
|
|
const tagType = u8;
|
|
|
|
const tag: std.meta.Tag(union_type) = @enumFromInt(std.mem.bytesAsValue(tagType, offset_mem[0..@sizeOf(tagType)]).*);
|
|
offset_mem = offset_mem[@sizeOf(tagType)..];
|
|
switch(tag) {
|
|
inline else => |union_field| {
|
|
const field = std.meta.fields(union_type)[@intFromEnum(union_field)];
|
|
switch(field.type) {
|
|
[]const u8 => {
|
|
const len = std.mem.bytesAsValue(u32, offset_mem[0..4]).*;
|
|
const str = try allocator.dupe(u8, offset_mem[4..(4+len)]);
|
|
@field(ret.*, field.name) = str;
|
|
offset_mem = offset_mem[4+len ..];
|
|
},
|
|
i8, u8, i16, u16, i32, u32,
|
|
i64, u64, i128, u128, i256, u256,
|
|
f32, f64 => {
|
|
@field(ret.*, field.name) = std.mem.bytesAsValue(field.type, offset_mem[0..@sizeOf(field.type)]).*;
|
|
offset_mem = offset_mem[@sizeOf(field.type)..];
|
|
},
|
|
else => blk: {
|
|
if(@typeInfo(field.type) == .@"struct") {
|
|
@field(ret.*, field.name) = (try StructDeserializer(field.type)(allocator, &offset_mem)).*;
|
|
break :blk;
|
|
} else if(@typeInfo(field.type) == .@"union") {
|
|
@field(ret.*, field.name) = (try UnionDeserializer(field.type)(allocator, &offset_mem)).*;
|
|
break :blk;
|
|
}
|
|
@compileLog(field.type);
|
|
@compileError("Unsupported type in StructDeserializer");
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
data.* = offset_mem;
|
|
return ret;
|
|
}
|
|
}.deserialize;
|
|
}
|
|
|
|
pub fn StructDeserializer(struct_type: type) fn(allocator: std.mem.Allocator, *[]const u8) std.mem.Allocator.Error!*struct_type {
|
|
return struct {
|
|
pub fn deserialize(allocator: std.mem.Allocator, data: *[]const u8) std.mem.Allocator.Error!*struct_type {
|
|
const ret = try allocator.create(struct_type);
|
|
var offset_mem = data.*;
|
|
const fields = std.meta.fields(struct_type);
|
|
inline for(fields) |field| {
|
|
switch(field.type) {
|
|
[]const u8 => {
|
|
const len = std.mem.bytesAsValue(u32, offset_mem[0..4]).*;
|
|
const str = try allocator.dupe(u8, offset_mem[4..(4+len)]);
|
|
@field(ret.*, field.name) = str;
|
|
offset_mem = offset_mem[4+len ..];
|
|
},
|
|
i8, u8, i16, u16, i32, u32,
|
|
i64, u64, i128, u128, i256, u256,
|
|
f32, f64 => {
|
|
std.log.debug("field_type: {} (offset_mem.len: {})", .{field.type, offset_mem.len});
|
|
@field(ret.*, field.name) = std.mem.bytesAsValue(field.type, offset_mem[0..@sizeOf(field.type)]).*;
|
|
offset_mem = offset_mem[@sizeOf(field.type)..];
|
|
},
|
|
else => blk: {
|
|
if(@typeInfo(field.type) == .@"struct") {
|
|
@field(ret.*, field.name) = (try StructDeserializer(field.type)(allocator, &offset_mem)).*;
|
|
break :blk;
|
|
} else if(@typeInfo(field.type) == .@"union") {
|
|
@field(ret.*, field.name) = (try UnionDeserializer(field.type)(allocator, &offset_mem)).*;
|
|
break :blk;
|
|
}
|
|
@compileLog(field.type);
|
|
@compileError("Unsupported type in StructDeserializer");
|
|
},
|
|
}
|
|
}
|
|
data.* = offset_mem;
|
|
std.log.debug("StructDeserializer Ended!", .{});
|
|
return ret;
|
|
}
|
|
}.deserialize;
|
|
}
|
|
|
|
pub const BoundVariant = enum(u8)
|
|
{
|
|
Inclusive = 0,
|
|
Exclusive = 1,
|
|
Unbounded = 2,
|
|
};
|
|
|
|
noinline fn lineInfo() usize {
|
|
return @returnAddress();
|
|
}
|
|
|
|
pub fn Iter(struct_type: type) type {
|
|
return struct {
|
|
allocator: std.mem.Allocator,
|
|
handle: spacetime.RowIter,
|
|
buffer: [0x20_000]u8 = undefined,
|
|
contents: ?[]u8 = null,
|
|
last_ret: SpacetimeValue = .OK,
|
|
|
|
pub fn next(self: *@This()) spacetime.ReducerError!?*struct_type {
|
|
std.log.debug("line: {} (handle: {})", .{358, self.handle});
|
|
var buffer_len: usize = undefined;
|
|
//while(true)
|
|
//{
|
|
var ret: spacetime.SpacetimeValue = self.last_ret;
|
|
if(self.contents == null or self.contents.?.len == 0) {
|
|
std.log.debug("line: {} (contents: {any})", .{364, self.contents});
|
|
if(self.handle._inner == spacetime.RowIter.INVALID._inner) {
|
|
std.log.debug("line: {}", .{366});
|
|
|
|
self.contents = null;
|
|
return null;
|
|
}
|
|
std.log.debug("line: {}", .{371});
|
|
|
|
buffer_len = self.buffer.len;
|
|
std.log.debug("line: {}", .{374});
|
|
ret = try spacetime.retMap(spacetime.row_iter_bsatn_advance(self.handle, @constCast(@ptrCast(&self.buffer)), &buffer_len));
|
|
std.log.debug("ret: {}", .{ret});
|
|
std.log.debug("self.buffer[0..buffer_len]: {any} {any} {any}", .{(&self.buffer).ptr, self.buffer.len, buffer_len});
|
|
self.contents = self.buffer[0..buffer_len];
|
|
std.log.debug("line: {}", .{379});
|
|
|
|
if(ret == .EXHAUSTED) {
|
|
std.log.debug("line: {}", .{382});
|
|
self.handle = spacetime.RowIter.INVALID;
|
|
}
|
|
std.log.debug("line: {}", .{385});
|
|
}
|
|
|
|
std.log.debug("{}", .{struct_type});
|
|
return StructDeserializer(struct_type)(self.allocator, &(self.contents.?));
|
|
//}
|
|
}
|
|
|
|
pub fn one_or_null(self: *@This()) ?*struct_type {
|
|
defer self.close();
|
|
return self.next() catch null;
|
|
}
|
|
|
|
pub fn close(self: *@This()) void {
|
|
_ = spacetime.row_iter_bsatn_close(self.handle);
|
|
self.handle = spacetime.RowIter.INVALID;
|
|
self.contents = null;
|
|
}
|
|
};
|
|
}
|
|
|
|
pub fn Column2ORM(comptime table_name: []const u8, comptime column_name: [:0]const u8) type {
|
|
const table = blk: {
|
|
for(spacetime.tables) |table| {
|
|
if(std.mem.eql(u8, table_name, table.name.?)) {
|
|
break :blk table;
|
|
}
|
|
}
|
|
@compileError("Table " ++ table_name ++ " does not exist!");
|
|
};
|
|
const struct_type = table.schema;
|
|
const column_type = utils.getMemberDefaultType(struct_type, column_name);
|
|
|
|
const wrapped_type = @Type(.{
|
|
.@"struct" = std.builtin.Type.Struct{
|
|
.backing_integer = null,
|
|
.decls = &.{},
|
|
.fields = &.{
|
|
std.builtin.Type.StructField{
|
|
.alignment = @alignOf(column_type),
|
|
.default_value = null,
|
|
.is_comptime = false,
|
|
.name = column_name,
|
|
.type = column_type,
|
|
}
|
|
},
|
|
.is_tuple = false,
|
|
.layout = .auto,
|
|
}
|
|
});
|
|
|
|
return struct {
|
|
allocator: std.mem.Allocator,
|
|
|
|
pub fn filter(self: @This(), val: wrapped_type) !Iter(struct_type) {
|
|
const temp_name: []const u8 = table_name ++ "_" ++ column_name ++ "_idx_btree";
|
|
var id = spacetime.IndexId{ ._inner = std.math.maxInt(u32)};
|
|
const err = try spacetime.retMap(spacetime.index_id_from_name(temp_name.ptr, temp_name.len, &id));
|
|
std.log.debug("index_id_from_name({}): {x}", .{err, id._inner});
|
|
|
|
const nVal: struct{ bounds: BoundVariant, val: wrapped_type } = .{
|
|
.bounds = .Inclusive,
|
|
.val = val,
|
|
};
|
|
|
|
const size: usize = getStructSize(nVal);
|
|
const mem = try self.allocator.alloc(u8, size);
|
|
var offset_mem = mem;
|
|
defer self.allocator.free(mem);
|
|
getStructData(nVal, &offset_mem);
|
|
|
|
const data = mem[0..size];
|
|
const rstart: []u8 = data[0..];
|
|
const rend: []u8 = data[0..];
|
|
|
|
var rowIter: spacetime.RowIter = undefined;
|
|
|
|
_ = try spacetime.retMap(spacetime.datastore_index_scan_range_bsatn(
|
|
id,
|
|
data.ptr, 0,
|
|
spacetime.ColId{ ._inner = 0},
|
|
rstart.ptr, rstart.len,
|
|
rend.ptr, rend.len,
|
|
&rowIter
|
|
));
|
|
|
|
return Iter(struct_type){
|
|
.allocator = self.allocator,
|
|
.handle = rowIter,
|
|
};
|
|
}
|
|
|
|
pub fn find(self: @This(), val: wrapped_type) !?*struct_type {
|
|
var iter = try self.filter(val);
|
|
return iter.one_or_null();
|
|
}
|
|
|
|
pub fn delete(self: @This(), val: wrapped_type) !void {
|
|
const temp_name: []const u8 = table_name ++ "_" ++ column_name ++ "_idx_btree";
|
|
var id = spacetime.IndexId{ ._inner = std.math.maxInt(u32)};
|
|
_ = spacetime.index_id_from_name(temp_name.ptr, temp_name.len, &id);
|
|
|
|
const nVal: struct{ bounds: BoundVariant, val: wrapped_type } = .{
|
|
.bounds = .Inclusive,
|
|
.val = val,
|
|
};
|
|
|
|
const size: usize = getStructSize(nVal);
|
|
const mem = try self.allocator.alloc(u8, size);
|
|
var offset_mem = mem;
|
|
defer self.allocator.free(mem);
|
|
getStructData(nVal, &offset_mem);
|
|
|
|
const data = mem[0..size];
|
|
const rstart: []u8 = data[0..];
|
|
const rend: []u8 = data[0..];
|
|
|
|
var deleted_fields: u32 = undefined;
|
|
|
|
_ = spacetime.datastore_delete_by_index_scan_range_bsatn(
|
|
id,
|
|
data.ptr, 0,
|
|
spacetime.ColId{ ._inner = 0},
|
|
rstart.ptr, rstart.len,
|
|
rend.ptr, rend.len,
|
|
&deleted_fields
|
|
);
|
|
}
|
|
};
|
|
}
|
|
|
|
pub fn Table2ORM(comptime table_name: []const u8) type {
|
|
const table = blk: {
|
|
for(spacetime.tables) |table| {
|
|
if(std.mem.eql(u8, table_name, table.name.?)) {
|
|
break :blk table;
|
|
}
|
|
}
|
|
};
|
|
const struct_type = table.schema;
|
|
|
|
return struct {
|
|
allocator: std.mem.Allocator,
|
|
|
|
pub fn insert(self: @This(), data: struct_type) !void {
|
|
var id: TableId = undefined;
|
|
_ = spacetime.table_id_from_name(table_name.ptr, table_name.len, &id);
|
|
const raw_data = try StructSerializer(struct_type)(self.allocator, data);
|
|
defer self.allocator.free(raw_data);
|
|
var raw_data_len: usize = raw_data.len;
|
|
_ = spacetime.datastore_insert_bsatn(id, raw_data.ptr, &raw_data_len);
|
|
}
|
|
|
|
pub fn iter(self: @This()) Iter(struct_type) {
|
|
var id: TableId = undefined;
|
|
_ = spacetime.table_id_from_name(table_name.ptr, table_name.len, &id);
|
|
var rowIter: spacetime.RowIter = undefined;
|
|
_ = spacetime.datastore_table_scan_bsatn(id, &rowIter);
|
|
return Iter(struct_type){
|
|
.allocator = self.allocator,
|
|
.handle = rowIter,
|
|
};
|
|
}
|
|
|
|
pub fn col(self: @This(), comptime column_name: [:0]const u8) Column2ORM(table_name, column_name) {
|
|
return .{
|
|
.allocator = self.allocator,
|
|
};
|
|
}
|
|
};
|
|
}
|
|
|
|
pub const Local = struct {
|
|
allocator: std.mem.Allocator,
|
|
|
|
pub fn get(self: @This(), comptime table: []const u8) Table2ORM(table) {
|
|
return .{
|
|
.allocator = self.allocator,
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const ReducerContext = struct {
|
|
sender: spacetime.Identity,
|
|
timestamp: spacetime.Timestamp,
|
|
connection_id: spacetime.ConnectionId,
|
|
db: Local,
|
|
};
|
|
|
|
pub const ReducerFn = fn(*ReducerContext) void;
|
|
|
|
pub const RawReducerDefV9 = struct {
|
|
name: RawIdentifier,
|
|
params: ProductType,
|
|
lifecycle: Lifecycle,
|
|
};
|
|
|
|
pub const RawScopedTypeNameV9 = struct {
|
|
scope: []RawIdentifier,
|
|
name: RawIdentifier,
|
|
};
|
|
|
|
pub const RawTypeDefV9 = struct {
|
|
name: RawScopedTypeNameV9,
|
|
ty: AlgebraicTypeRef,
|
|
custom_ordering: bool,
|
|
};
|
|
|
|
pub const RawMiscModuleExportV9 = enum {
|
|
RESERVED,
|
|
};
|
|
|
|
pub const RawSql = []u8;
|
|
|
|
pub const RawRowLevelSecurityDefV9 = struct {
|
|
sql: RawSql,
|
|
};
|
|
|
|
pub const RawModuleDefV9 = struct {
|
|
typespace: Typespace,
|
|
tables: []const RawTableDefV9,
|
|
reducers: []const RawReducerDefV9,
|
|
types: []const RawTypeDefV9,
|
|
misc_exports: []const RawMiscModuleExportV9,
|
|
row_level_security: []const RawRowLevelSecurityDefV9,
|
|
};
|