diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/db/sqlite.zig | 584 | ||||
| -rw-r--r-- | src/zilch/Env/value.sync-conflict-20261030-190805-2JYANE7.zig | 185 | ||||
| -rw-r--r-- | src/zilch/app/load.js | 4 | ||||
| -rw-r--r-- | src/zilch/bridge/root.zig | 40 | ||||
| -rw-r--r-- | src/zilch/bridge/server.root.zig | 10 | ||||
| -rw-r--r-- | src/zilch/bridge/wasm.root.zig | 0 | ||||
| -rw-r--r-- | src/zilch/root.zig | 2 |
7 files changed, 554 insertions, 271 deletions
diff --git a/src/db/sqlite.zig b/src/db/sqlite.zig index 0ef1b20..57fe75c 100644 --- a/src/db/sqlite.zig +++ b/src/db/sqlite.zig @@ -1,7 +1,8 @@ -const std = @import("std"); +const std = @import("std"); const sqlite = @import("sqlite"); const assert = std.debug.assert; +const Alignment = std.mem.Alignment; const Allocator = std.mem.Allocator; const Writer = std.Io.Writer; @@ -16,11 +17,12 @@ pub fn Database(comptime T: type) type { // a (useless) schema that does not define any tables. const TagIntTables = @Int(.unsigned, @bitSizeOf(@TypeOf(tables.len)) - @clz(tables.len)); - var table_names: [tables.len][]const u8 = undefined; - var table_types: [tables.len]type = undefined; + var table_names : [tables.len][]const u8 = undefined; + var table_types : [tables.len]type = undefined; var table_values: [tables.len]TagIntTables = undefined; + var statements : [tables.len][:0]const u8 = undefined; - inline for (&table_names, &table_types, &table_values, tables, 0..) |*table_name, *table_type, *table_value, table, table_index| { + inline for (&table_names, &table_types, &table_values, &statements, tables, 0..) |*table_name, *table_type, *table_value, *statement, table, table_index| { const columns = switch (@typeInfo(table.type)) { .@"struct" => |s| s.fields, else => @compileError("Table `" ++ table.name ++ "` must be of type `struct`"), @@ -32,32 +34,45 @@ pub fn Database(comptime T: type) type { const TagIntColumns = @Int(.unsigned, std.math.log2_int_ceil(@TypeOf(columns.len), columns.len)); - var column_names: [columns.len][]const u8 = undefined; - var column_types: [columns.len]type = undefined; + var column_names : [columns.len][]const u8 = undefined; + var column_types : [columns.len]type = undefined; var column_values: [columns.len]TagIntColumns = undefined; + var create_table : [:0]const u8 = "CREATE TABLE IF NOT EXISTS " ++ table.name ++ " ("; inline for (&column_names, &column_types, &column_values, columns, 0..) |*column_name, *column_type, *column_value, column, column_index| { if (!isTypename(column.type)) @compileError("Column `" ++ column.name ++ "` must be of type `Typename`"); - const column_field_value = std.builtin.Type.StructField.defaultValue(column) orelse @compileError("Column `" ++ column.name ++ "` is missing value"); + const typename = std.builtin.Type.StructField.defaultValue(column) orelse @compileError("Column `" ++ column.name ++ "` is missing value"); + const separator = if (column_index == 0) "" else ", "; - // TODO: use `column_field_value` to build `CREATE TABLE` SQLite statement + const Context = struct { + typename: @TypeOf(typename), + + pub fn format(self: @This(), writer: *Writer) Writer.Error!void { + try self.typename.serialise(writer); + } + }; + const format = std.fmt.alt(Context{ .typename = typename }, .format); column_name.* = column.name; - column_type.* = column_field_value.type; + column_type.* = typename.type; column_value.* = column_index; + create_table = create_table ++ std.fmt.comptimePrint("{s}{s} {f}", .{ separator, column.name, format }); } const TagColumns = @Enum(TagIntColumns, .exhaustive, &column_names, &column_values); - const Columns = @Union(.auto, TagColumns, &column_names, &column_types, &@splat(.{})); + const Columns = @Union(.auto, TagColumns, &column_names, &column_types, &@splat(.{})); - table_name.* = table.name; - table_type.* = Columns; + table_name.* = table.name; + table_type.* = Columns; table_value.* = table_index; + statement.* = create_table ++ ");"; } const TagTables = @Enum(TagIntTables, .exhaustive, &table_names, &table_values); - const Tables = @Union(.auto, TagTables, &table_names, &table_types, &@splat(.{})); + const Tables = @Union(.auto, TagTables, &table_names, &table_types, &@splat(.{})); + + const create_tables = statements; return struct { handle: *sqlite.sqlite3, @@ -67,62 +82,151 @@ pub fn Database(comptime T: type) type { busy, }; - pub const Error = set: { - var set: type = error{}; - - for (std.meta.fieldNames(Result.Primary)) |name| { - set = set || @TypeOf(@field(anyerror, name)); - } - for (std.meta.fieldNames(Result.Extended)) |name| { - set = set || @TypeOf(@field(anyerror, name)); - } - - break :set set; - }; + pub const Error = Result.Error; pub const Kind = union(enum) { temp_in_memory, temp_on_disk, - path: []const u8, + path: [:0]const u8, }; const Schema = Tables; const Self = @This(); // Source: https://sqlite.org/c3ref/open.html + // NOTE: caller must close db connection if fn returns error or if db + // is no longer needed to prevent ressource leaks pub fn init(kind: Kind) Error!Self { const name = switch (kind) { .temp_in_memory => ":memory:", - .temp_on_disk => "", - .path => |path| path, + .temp_on_disk => "", + .path => |path| path, }; - var handle: ?*sqlite.sqlite3 = null; - const result: Result = .from(sqlite.sqlite3_open(name.ptr, &handle)); - const primary = result.asPrimary(); + const self: Self = open: { + var handle : ?*sqlite.sqlite3 = null; - if (primary != .ok) return result.toError(Error, handle); - - return .{ .handle = handle.? }; + const open = try Result.from(sqlite.sqlite3_open(name.ptr, &handle)) + .orElse(sqlite.sqlite3_extended_errcode, .{ handle }) + .toErrorUnion(); + + const enable_extended = try Result.from(sqlite.sqlite3_extended_result_codes(handle, 1)) + .toErrorUnion(); + + assert(open == .ok); + assert(enable_extended == .ok); + + break :open .{ .handle = handle.? }; + }; + + for (create_tables) |create_table| { + const exec = try Result.from(sqlite.sqlite3_exec(self.handle, create_table.ptr, null, null, null)) + .toErrorUnion(); + + assert(exec == .ok); + } + + return self; } // See https://sqlite.org/c3ref/close.html pub fn deinit(self: *Self) Deinit { - const result: Result = .from(sqlite.sqlite3_close(self.handle)); - const primary = result.asPrimary(); + const close: Result = .from(sqlite.sqlite3_close(self.handle)); - if (primary == .busy) return .busy; + if (close == .ok) { + self.* = undefined; + return .ok; + } - self.* = undefined; - return .ok; + return .busy; } // NOTE: SELECT without FROM is non-conforming SQL // https://stackoverflow.com/questions/3732422/select-from-nothing // https://modern-sql.com/use-case/select-without-from - pub fn select(self: Self, comptime from: std.meta.Tag(Schema), comptime columns: []const std.meta.Tag(@FieldType(Schema, @tagName(from)))) Select(Schema, from, columns) { - return .{ .handle = self.handle }; + pub fn select(self: *Self, comptime from: std.meta.Tag(Schema), comptime columns: []const std.meta.Tag(@FieldType(Schema, @tagName(from)))) Select(Self, from, columns) { + return .{ .database = self }; } + + // https://cs.stackexchange.com/questions/138556/how-to-find-the-largest-power-of-two-divisor-of-a-given-integer + // const num: usize = 24; + // std.debug.print("{}\n", .{ num & (~num + 1) }); // same as num & -num +// fn allocator(self: *const Self) Allocator { +// _ = self; +// +// const Functions = struct { +// // https://stackoverflow.com/questions/227897/how-to-allocate-aligned-memory-only-using-the-standard-library +// fn allocHeader(aligned_ptr: [*]u8) *[*]u8 { +// return @ptrCast(@alignCast(aligned_ptr - @sizeOf(usize))); +// } +// +// fn alloc(ctx: *anyopaque, len: usize, alignment: Alignment, ret_addr: usize) ?[*]u8 { +// _ = ctx; +// _ = ret_addr; +// +// // unaligned_ptr aligned_ptr +// // v v +// // +----------+----------+------------------------------+ +// // | padding | header | usable bytes | +// // +----------+----------+------------------------------+ +// const total_len = (alignment.toByteUnits() - 1) + @sizeOf(usize) + len; +// const allocation = sqlite.sqlite3_malloc64(total_len) orelse return null; +// +// const unaligned_ptr: [*]u8 = @ptrCast(allocation); +// const unaligned_addr = @intFromPtr(unaligned_ptr); +// +// const aligned_addr = alignment.forward(unaligned_addr + @sizeOf(usize)); +// const aligned_ptr = unaligned_ptr + (aligned_addr - unaligned_addr); +// +// allocHeader(aligned_ptr).* = unaligned_ptr; +// +// return aligned_ptr; +// } +// +// fn free(ctx: *anyopaque, memory: []u8, alignment: Alignment, ret_addr: usize) void { +// _ = ctx; +// _ = alignment; +// _ = ret_addr; +// +// sqlite.sqlite3_free(allocHeader(memory.ptr).*); +// } +// +// fn remap(ctx: *anyopaque, memory: []u8, alignment: Alignment, new_len: usize, ret_addr: usize) ?[*]u8 { +// if (resize(ctx, memory, alignment, new_len, ret_addr)) return memory.ptr; +// +// // `sqlite.sqlite3_realloc64` may return a new allocation +// // with a different alignment than the original allocation, +// // so we just give up. +// return null; +// } +// +// fn resize(ctx: *anyopaque, memory: []u8, alignment: Alignment, new_len: usize, ret_addr: usize) bool { +// _ = ctx; +// _ = alignment; +// _ = ret_addr; +// +// if (new_len <= memory.len) return true; +// +// const unaligned_ptr = allocHeader(memory.ptr).*; +// const overallocation = @intFromPtr(memory.ptr) - @intFromPtr(unaligned_ptr); +// +// const total_len = sqlite.sqlite3_msize(unaligned_ptr); +// const usable_len = total_len - overallocation; +// +// return new_len <= usable_len; +// } +// }; +// +// return .{ +// .ptr = undefined, +// .vtable = &.{ +// .alloc = Functions.alloc, +// .free = Functions.free, +// .remap = Functions.remap, +// .resize = Functions.resize, +// }, +// }; +// } }; } @@ -138,7 +242,7 @@ const Affinity = enum { const Value = union(Affinity) { integer: i64, real : f64, - text : []const u8, + text : [:0]const u8, fn FieldType(comptime field: std.meta.Tag(Value)) type { return @FieldType(Value, @tagName(field)); @@ -240,9 +344,10 @@ fn isTypename(comptime T: type) bool { return T == Typename(affinity); } -fn Select(comptime Schema: type, comptime from: std.meta.Tag(Schema), comptime columns: []const std.meta.Tag(@FieldType(Schema, @tagName(from)))) type { +fn Select(comptime Db: type, comptime from: std.meta.Tag(Db.Schema), comptime columns: []const std.meta.Tag(@FieldType(Db.Schema, @tagName(from)))) type { if (columns.len == 0) @compileError("At least one column must be selected"); + const PrepareError = Allocator.Error || Db.Error; const TagIntColumns = @Int(.unsigned, std.math.log2_int_ceil(@TypeOf(columns.len), columns.len)); var column_names : [columns.len][]const u8 = undefined; @@ -252,7 +357,7 @@ fn Select(comptime Schema: type, comptime from: std.meta.Tag(Schema), comptime c inline for (&column_names, &column_types, &column_values, columns, 0..) |*column_name, *column_type, *column_value, column,column_index| { column_name.* = @tagName(column); column_value.* = column_index; - column_type.* = @FieldType(@FieldType(Schema, @tagName(from)), @tagName(column)); + column_type.* = @FieldType(@FieldType(Db.Schema, @tagName(from)), @tagName(column)); } // NOTE: Uniqueness of selected columns is enforced here. @@ -260,7 +365,7 @@ fn Select(comptime Schema: type, comptime from: std.meta.Tag(Schema), comptime c const Selected = @Union(.auto, TagColumns, &column_names, &column_types, &@splat(.{})); return struct { - handle: *sqlite.sqlite3, + database: *Db, filter: Filter = .none, // sort: ..., // ORDER BY @@ -317,97 +422,6 @@ fn Select(comptime Schema: type, comptime from: std.meta.Tag(Schema), comptime c .some => |n| n, }; } - - // pub fn format(self: Filter, writer: *Writer) Writer.Error!void { - // const State = struct { - // index: usize = 0, - // node : ?*const Filter.Node = null, - // last_node: enum{ binary_expression, cmp, none } = .none, - // parentheses: isize = -1, - // - // const init: @This() = .{}; - // }; - // - // var state: State = .init; - // - // while (state.index < self.nodes.len) { - // switch (self.nodes[state.index]) { - // .@"and", .@"or" => { - // if (state.node) |node| { - // if (state.last_node == .cmp) { - // try writer.print(" {f} ", .{ node }); - // } - // } - // if (state.parentheses >= 0) try writer.writeByte('('); - // state.node = &self.nodes[state.index]; - // state.index += 1; - // state.last_node = .binary_expression; - // state.parentheses += 1; - // }, - // .cmp => { - // if (state.node) |node| { - // const index = node[0..1] - self.nodes.ptr; - // const parent = if (index > 0) &self.nodes[index - 1] else null; - // - // switch (node.*) { - // .@"and" => |value| { - // switch (self.nodes[index + value.lhs]) { - // .cmp => { - // try writer.print("{f}", .{ self.nodes[index + value.lhs] }); - // state.index += 1; - // }, - // else => {}, - // } - // try writer.print(" {f} ", .{ node }); - // switch (self.nodes[index + value.rhs]) { - // .cmp => { - // try writer.print("{f}", .{ self.nodes[index + value.rhs] }); - // state.index += 1; - // }, - // else => {}, - // } - // if (state.parentheses > 0) try writer.writeByte(')'); - // - // state.node = parent; - // state.parentheses -= 1; - // }, - // .@"or" => |value| { - // switch (self.nodes[index + value.lhs]) { - // .cmp => { - // try writer.print("{f}", .{ self.nodes[index + value.lhs] }); - // state.index += 1; - // }, - // else => {}, - // } - // try writer.print(" {f} ", .{ node }); - // switch (self.nodes[index + value.rhs]) { - // .cmp => { - // try writer.print("{f}", .{ self.nodes[index + value.rhs] }); - // state.index += 1; - // }, - // else => {}, - // } - // if (state.parentheses > 0) try writer.writeByte(')'); - // - // state.node = parent; - // state.parentheses -= 1; - // }, - // .cmp => unreachable, - // } - // } else { - // try writer.print("{f}", .{ self.nodes[state.index] }); - // state.index += 1; - // } - // state.last_node = .cmp; - // }, - // } - // } - // - // var index = state.parentheses; - // while (index > 0) : (index -= 1) { - // try writer.writeByte(')'); - // } - // } }; pub const Limit = union(enum) { @@ -449,9 +463,8 @@ fn Select(comptime Schema: type, comptime from: std.meta.Tag(Schema), comptime c return this; } - // FIXME: change return type to sql stmt and update error type - // TODO: return type must be SQLite stmt value; can error also be SQLite error? if so, make union with allocator.error - pub fn prepare(self: Self, allocator: Allocator) Allocator.Error!void { + // TODO + pub fn prepare(self: Self, allocator: Allocator) PrepareError!Statement { var allocating_writer: std.Io.Writer.Allocating = .init(allocator); defer allocating_writer.deinit(); @@ -462,7 +475,9 @@ fn Select(comptime Schema: type, comptime from: std.meta.Tag(Schema), comptime c const string = try allocating_writer.toOwnedSlice(); defer allocator.free(string); + // TODO: prepare statement std.debug.print("{s}\n", .{ string }); + return .{}; } pub fn where(self: Self, comptime filter: Filter) Self { @@ -481,7 +496,7 @@ fn Select(comptime Schema: type, comptime from: std.meta.Tag(Schema), comptime c try writer.writeAll(" DISTINCT"); } - const all_columns_selected: bool = columns.len == std.meta.fields(@FieldType(Schema, @tagName(from))).len; + const all_columns_selected: bool = columns.len == std.meta.fields(@FieldType(Db.Schema, @tagName(from))).len; if (all_columns_selected) { try writer.writeAll(" *"); @@ -490,7 +505,7 @@ fn Select(comptime Schema: type, comptime from: std.meta.Tag(Schema), comptime c try writer.writeAll(separator); try writer.writeAll(@tagName(column)); -} + } switch (self.filter) { .none => {}, @@ -609,19 +624,42 @@ fn Select(comptime Schema: type, comptime from: std.meta.Tag(Schema), comptime c } }; } -/// SQLite result codes. -/// -/// Primary result codes define a broad category of results, whereas extended -/// result codes provide more detail. The primary result code is always part of -/// an extended result code. -/// -/// See https://sqlite.org/rescode.html -const Result = enum(i32) { - _, + +pub const Statement = struct { + pub fn deinit(self: *Statement) void { + self.* = undefined; + } +}; + +// Result models Result Codes +// ok,done,row are the only non-error result codes +const Result = union(enum) { + err: Error, + ok : Ok, + + // Error models Error Codes + const Error = set: { + var set: type = error{}; + + for (std.meta.tags(Primary)) |tag| { + if (!tag.isError()) continue; + set = set || @TypeOf(@field(anyerror, @tagName(tag))); + } + for (std.meta.fieldNames(Extended)) |name| { + set = set || @TypeOf(@field(anyerror, name)); + } + + break :set set; + }; + + const Ok = enum { + ok, + row, + done, + }; // zig fmt: off - /// Primary result codes. - const Primary = enum(u8) { + const Primary = enum(i32) { ok = 0, @"error" = 1, internal = 2, @@ -654,124 +692,125 @@ const Result = enum(i32) { row = 100, done = 101, - /// Returns the primary result code as type `T`. - fn as(self: Primary, comptime T: type) T { - return @as(T, @intFromEnum(self)); + fn isError(self: Primary) bool { + return switch (self) { + .ok, .row, .done => false, + else => true, + }; } }; - /// Extended result codes. const Extended = enum(i32) { - error_missing_collseq = (Primary.@"error".as(i32) | ( 1 << 8)), - error_retry = (Primary.@"error".as(i32) | ( 2 << 8)), - error_snapshot = (Primary.@"error".as(i32) | ( 3 << 8)), - error_reservesize = (Primary.@"error".as(i32) | ( 4 << 8)), - error_key = (Primary.@"error".as(i32) | ( 5 << 8)), - error_unable = (Primary.@"error".as(i32) | ( 6 << 8)), - ioerr_read = (Primary.ioerr.as(i32) | ( 1 << 8)), - ioerr_short_read = (Primary.ioerr.as(i32) | ( 2 << 8)), - ioerr_write = (Primary.ioerr.as(i32) | ( 3 << 8)), - ioerr_fsync = (Primary.ioerr.as(i32) | ( 4 << 8)), - ioerr_dir_fsync = (Primary.ioerr.as(i32) | ( 5 << 8)), - ioerr_truncate = (Primary.ioerr.as(i32) | ( 6 << 8)), - ioerr_fstat = (Primary.ioerr.as(i32) | ( 7 << 8)), - ioerr_unlock = (Primary.ioerr.as(i32) | ( 8 << 8)), - ioerr_rdlock = (Primary.ioerr.as(i32) | ( 9 << 8)), - ioerr_delete = (Primary.ioerr.as(i32) | (10 << 8)), - ioerr_blocked = (Primary.ioerr.as(i32) | (11 << 8)), - ioerr_nomem = (Primary.ioerr.as(i32) | (12 << 8)), - ioerr_access = (Primary.ioerr.as(i32) | (13 << 8)), - ioerr_checkreservedlock = (Primary.ioerr.as(i32) | (14 << 8)), - ioerr_lock = (Primary.ioerr.as(i32) | (15 << 8)), - ioerr_close = (Primary.ioerr.as(i32) | (16 << 8)), - ioerr_dir_close = (Primary.ioerr.as(i32) | (17 << 8)), - ioerr_shmopen = (Primary.ioerr.as(i32) | (18 << 8)), - ioerr_shmsize = (Primary.ioerr.as(i32) | (19 << 8)), - ioerr_shmlock = (Primary.ioerr.as(i32) | (20 << 8)), - ioerr_shmmap = (Primary.ioerr.as(i32) | (21 << 8)), - ioerr_seek = (Primary.ioerr.as(i32) | (22 << 8)), - ioerr_delete_noent = (Primary.ioerr.as(i32) | (23 << 8)), - ioerr_mmap = (Primary.ioerr.as(i32) | (24 << 8)), - ioerr_gettemppath = (Primary.ioerr.as(i32) | (25 << 8)), - ioerr_convpath = (Primary.ioerr.as(i32) | (26 << 8)), - ioerr_vnode = (Primary.ioerr.as(i32) | (27 << 8)), - ioerr_auth = (Primary.ioerr.as(i32) | (28 << 8)), - ioerr_begin_atomic = (Primary.ioerr.as(i32) | (29 << 8)), - ioerr_commit_atomic = (Primary.ioerr.as(i32) | (30 << 8)), - ioerr_rollback_atomic = (Primary.ioerr.as(i32) | (31 << 8)), - ioerr_data = (Primary.ioerr.as(i32) | (32 << 8)), - ioerr_corruptfs = (Primary.ioerr.as(i32) | (33 << 8)), - ioerr_in_page = (Primary.ioerr.as(i32) | (34 << 8)), - ioerr_badkey = (Primary.ioerr.as(i32) | (35 << 8)), - ioerr_codec = (Primary.ioerr.as(i32) | (36 << 8)), - locked_sharedcache = (Primary.locked.as(i32) | ( 1 << 8)), - locked_vtab = (Primary.locked.as(i32) | ( 2 << 8)), - busy_recovery = (Primary.busy.as(i32) | ( 1 << 8)), - busy_snapshot = (Primary.busy.as(i32) | ( 2 << 8)), - busy_timeout = (Primary.busy.as(i32) | ( 3 << 8)), - cantopen_notempdir = (Primary.cantopen.as(i32) | ( 1 << 8)), - cantopen_isdir = (Primary.cantopen.as(i32) | ( 2 << 8)), - cantopen_fullpath = (Primary.cantopen.as(i32) | ( 3 << 8)), - cantopen_convpath = (Primary.cantopen.as(i32) | ( 4 << 8)), - cantopen_symlink = (Primary.cantopen.as(i32) | ( 6 << 8)), - corrupt_vtab = (Primary.corrupt.as(i32) | ( 1 << 8)), - corrupt_sequence = (Primary.corrupt.as(i32) | ( 2 << 8)), - corrupt_index = (Primary.corrupt.as(i32) | ( 3 << 8)), - readonly_recovery = (Primary.readonly.as(i32) | ( 1 << 8)), - readonly_cantlock = (Primary.readonly.as(i32) | ( 2 << 8)), - readonly_rollback = (Primary.readonly.as(i32) | ( 3 << 8)), - readonly_dbmoved = (Primary.readonly.as(i32) | ( 4 << 8)), - readonly_cantinit = (Primary.readonly.as(i32) | ( 5 << 8)), - readonly_directory = (Primary.readonly.as(i32) | ( 6 << 8)), - abort_rollback = (Primary.abort.as(i32) | ( 2 << 8)), - constraint_check = (Primary.constraint.as(i32) | ( 1 << 8)), - constraint_commithook = (Primary.constraint.as(i32) | ( 2 << 8)), - constraint_foreignkey = (Primary.constraint.as(i32) | ( 3 << 8)), - constraint_function = (Primary.constraint.as(i32) | ( 4 << 8)), - constraint_notnull = (Primary.constraint.as(i32) | ( 5 << 8)), - constraint_primarykey = (Primary.constraint.as(i32) | ( 6 << 8)), - constraint_trigger = (Primary.constraint.as(i32) | ( 7 << 8)), - constraint_unique = (Primary.constraint.as(i32) | ( 8 << 8)), - constraint_vtab = (Primary.constraint.as(i32) | ( 9 << 8)), - constraint_rowid = (Primary.constraint.as(i32) | (10 << 8)), - constraint_pinned = (Primary.constraint.as(i32) | (11 << 8)), - constraint_datatype = (Primary.constraint.as(i32) | (12 << 8)), - notice_recover_wal = (Primary.notice.as(i32) | ( 1 << 8)), - notice_recover_rollback = (Primary.notice.as(i32) | ( 2 << 8)), - notice_rbu = (Primary.notice.as(i32) | ( 3 << 8)), - warning_autoindex = (Primary.warning.as(i32) | ( 1 << 8)), - auth_user = (Primary.auth.as(i32) | ( 1 << 8)), - ok_load_permanently = (Primary.ok.as(i32) | ( 1 << 8)), + error_missing_collseq = @intFromEnum(Primary.@"error") | ( 1 << 8), + error_retry = @intFromEnum(Primary.@"error") | ( 2 << 8), + error_snapshot = @intFromEnum(Primary.@"error") | ( 3 << 8), + error_reservesize = @intFromEnum(Primary.@"error") | ( 4 << 8), + error_key = @intFromEnum(Primary.@"error") | ( 5 << 8), + error_unable = @intFromEnum(Primary.@"error") | ( 6 << 8), + ioerr_read = @intFromEnum(Primary.ioerr) | ( 1 << 8), + ioerr_short_read = @intFromEnum(Primary.ioerr) | ( 2 << 8), + ioerr_write = @intFromEnum(Primary.ioerr) | ( 3 << 8), + ioerr_fsync = @intFromEnum(Primary.ioerr) | ( 4 << 8), + ioerr_dir_fsync = @intFromEnum(Primary.ioerr) | ( 5 << 8), + ioerr_truncate = @intFromEnum(Primary.ioerr) | ( 6 << 8), + ioerr_fstat = @intFromEnum(Primary.ioerr) | ( 7 << 8), + ioerr_unlock = @intFromEnum(Primary.ioerr) | ( 8 << 8), + ioerr_rdlock = @intFromEnum(Primary.ioerr) | ( 9 << 8), + ioerr_delete = @intFromEnum(Primary.ioerr) | (10 << 8), + ioerr_blocked = @intFromEnum(Primary.ioerr) | (11 << 8), + ioerr_nomem = @intFromEnum(Primary.ioerr) | (12 << 8), + ioerr_access = @intFromEnum(Primary.ioerr) | (13 << 8), + ioerr_checkreservedlock = @intFromEnum(Primary.ioerr) | (14 << 8), + ioerr_lock = @intFromEnum(Primary.ioerr) | (15 << 8), + ioerr_close = @intFromEnum(Primary.ioerr) | (16 << 8), + ioerr_dir_close = @intFromEnum(Primary.ioerr) | (17 << 8), + ioerr_shmopen = @intFromEnum(Primary.ioerr) | (18 << 8), + ioerr_shmsize = @intFromEnum(Primary.ioerr) | (19 << 8), + ioerr_shmlock = @intFromEnum(Primary.ioerr) | (20 << 8), + ioerr_shmmap = @intFromEnum(Primary.ioerr) | (21 << 8), + ioerr_seek = @intFromEnum(Primary.ioerr) | (22 << 8), + ioerr_delete_noent = @intFromEnum(Primary.ioerr) | (23 << 8), + ioerr_mmap = @intFromEnum(Primary.ioerr) | (24 << 8), + ioerr_gettemppath = @intFromEnum(Primary.ioerr) | (25 << 8), + ioerr_convpath = @intFromEnum(Primary.ioerr) | (26 << 8), + ioerr_vnode = @intFromEnum(Primary.ioerr) | (27 << 8), + ioerr_auth = @intFromEnum(Primary.ioerr) | (28 << 8), + ioerr_begin_atomic = @intFromEnum(Primary.ioerr) | (29 << 8), + ioerr_commit_atomic = @intFromEnum(Primary.ioerr) | (30 << 8), + ioerr_rollback_atomic = @intFromEnum(Primary.ioerr) | (31 << 8), + ioerr_data = @intFromEnum(Primary.ioerr) | (32 << 8), + ioerr_corruptfs = @intFromEnum(Primary.ioerr) | (33 << 8), + ioerr_in_page = @intFromEnum(Primary.ioerr) | (34 << 8), + ioerr_badkey = @intFromEnum(Primary.ioerr) | (35 << 8), + ioerr_codec = @intFromEnum(Primary.ioerr) | (36 << 8), + locked_sharedcache = @intFromEnum(Primary.locked) | ( 1 << 8), + locked_vtab = @intFromEnum(Primary.locked) | ( 2 << 8), + busy_recovery = @intFromEnum(Primary.busy) | ( 1 << 8), + busy_snapshot = @intFromEnum(Primary.busy) | ( 2 << 8), + busy_timeout = @intFromEnum(Primary.busy) | ( 3 << 8), + cantopen_notempdir = @intFromEnum(Primary.cantopen) | ( 1 << 8), + cantopen_isdir = @intFromEnum(Primary.cantopen) | ( 2 << 8), + cantopen_fullpath = @intFromEnum(Primary.cantopen) | ( 3 << 8), + cantopen_convpath = @intFromEnum(Primary.cantopen) | ( 4 << 8), + cantopen_symlink = @intFromEnum(Primary.cantopen) | ( 6 << 8), + corrupt_vtab = @intFromEnum(Primary.corrupt) | ( 1 << 8), + corrupt_sequence = @intFromEnum(Primary.corrupt) | ( 2 << 8), + corrupt_index = @intFromEnum(Primary.corrupt) | ( 3 << 8), + readonly_recovery = @intFromEnum(Primary.readonly) | ( 1 << 8), + readonly_cantlock = @intFromEnum(Primary.readonly) | ( 2 << 8), + readonly_rollback = @intFromEnum(Primary.readonly) | ( 3 << 8), + readonly_dbmoved = @intFromEnum(Primary.readonly) | ( 4 << 8), + readonly_cantinit = @intFromEnum(Primary.readonly) | ( 5 << 8), + readonly_directory = @intFromEnum(Primary.readonly) | ( 6 << 8), + abort_rollback = @intFromEnum(Primary.abort) | ( 2 << 8), + constraint_check = @intFromEnum(Primary.constraint) | ( 1 << 8), + constraint_commithook = @intFromEnum(Primary.constraint) | ( 2 << 8), + constraint_foreignkey = @intFromEnum(Primary.constraint) | ( 3 << 8), + constraint_function = @intFromEnum(Primary.constraint) | ( 4 << 8), + constraint_notnull = @intFromEnum(Primary.constraint) | ( 5 << 8), + constraint_primarykey = @intFromEnum(Primary.constraint) | ( 6 << 8), + constraint_trigger = @intFromEnum(Primary.constraint) | ( 7 << 8), + constraint_unique = @intFromEnum(Primary.constraint) | ( 8 << 8), + constraint_vtab = @intFromEnum(Primary.constraint) | ( 9 << 8), + constraint_rowid = @intFromEnum(Primary.constraint) | (10 << 8), + constraint_pinned = @intFromEnum(Primary.constraint) | (11 << 8), + constraint_datatype = @intFromEnum(Primary.constraint) | (12 << 8), + notice_recover_wal = @intFromEnum(Primary.notice) | ( 1 << 8), + notice_recover_rollback = @intFromEnum(Primary.notice) | ( 2 << 8), + notice_rbu = @intFromEnum(Primary.notice) | ( 3 << 8), + warning_autoindex = @intFromEnum(Primary.warning) | ( 1 << 8), + auth_user = @intFromEnum(Primary.auth) | ( 1 << 8), + ok_load_permanently = @intFromEnum(Primary.ok) | ( 1 << 8), }; // zig fmt: on - /// Returns the result code corresponding to the given integer value. - fn from(integer: anytype) Result { - assert(std.enums.fromInt(Primary, integer) != null or std.enums.fromInt(Extended, integer) != null); - - return @enumFromInt(integer); + fn from(code: c_int) Result { + if (std.enums.fromInt(Primary, code)) |primary| switch (primary) { + .ok => return .{ .ok = .ok }, + .row => return .{ .ok = .row }, + .done => return .{ .ok = .done }, + inline else => |error_name| return .{ .err = @field(Error, @tagName(error_name)) }, + } else if (std.enums.fromInt(Extended, code)) |extended| switch (extended) { + inline else => |error_name| return .{ .err = @field(Error, @tagName(error_name)) }, + } else { + unreachable; + } } - /// Returns the error name corresponding to the result code. The `handle` is - /// needed to fetch the extended result code, if it exists, only if `self` - /// is not already an extended result code. - fn toError(self: Result, comptime Error: type, handle: ?*sqlite.sqlite3) Error { - if (std.enums.fromInt(Extended, @intFromEnum(self))) |extended| switch (extended) { - inline else => |code| return @field(Error, @tagName(code)), - }; - - const value: Result = .from(sqlite.sqlite3_extended_errcode(handle)); + fn orElse(self: Result, function: anytype, args: anytype) Result { + comptime { assert(@typeInfo(@TypeOf(function)).@"fn".return_type == c_int); } - if (std.enums.fromInt(Extended, @intFromEnum(value))) |extended| switch (extended) { - inline else => |code| return @field(Error, @tagName(code)), - } else switch (self.asPrimary()) { - inline else => |code| return @field(Error, @tagName(code)), - } + return switch (self) { + .ok => self, + .err => .from(@call(.auto, function, args)), + }; } - /// Returns the primary result code. - fn asPrimary(self: Result) Primary { - return @enumFromInt(0x000000FF & @intFromEnum(self)); + fn toErrorUnion(self: Result) Error!Ok { + return switch (self) { + .ok => |okay| okay, + .err => |error_name| error_name, + }; } }; @@ -830,18 +869,25 @@ test { var db: Database(Schema) = try .init(.temp_in_memory); defer assert(db.deinit() == .ok); - const query = try db.select(.contacts, &.{ .first_name , .last_name, .age }) - // TODO: convert to tests - // .where(.cmp(.first_name, .eql, "Bob")) - // .where(.@"and"(.cmp(.first_name, .eql, "Bob"), .cmp(.age, .geq, 42))) - // .where(.@"and"(.@"and"(.cmp(.first_name, .eql, "Bob"), .cmp(.age, .geq, 42)), .cmp(.last_name, .is_not, "Smith"))) - // .where(.@"or"(.@"and"(.cmp(.first_name, .eql, "Bob"), .cmp(.age, .geq, 42)), .@"and"(.cmp(.age, .eql, 69), .cmp(.last_name, .is_not, "Smith")))) - .where(.@"or"(.@"and"(.@"and"(.cmp(.first_name, .eql, "Bob"), .cmp(.age, .geq, 42)), .cmp(.last_name, .is_not, "Smith")), .cmp(.age, .eql, 69))) - .distinct() - .limit(.{ .count = 25 }) - .prepare(allocator); + const query = db.select(.contacts, &.{ .first_name , .last_name, .age }) + // TODO: convert to tests + // .where(.cmp(.first_name, .eql, "Bob")) + // .where(.@"and"(.cmp(.first_name, .eql, "Bob"), .cmp(.age, .geq, 42))) + // .where(.@"and"(.@"and"(.cmp(.first_name, .eql, "Bob"), .cmp(.age, .geq, 42)), .cmp(.last_name, .is_not, "Smith"))) + // .where(.@"or"(.@"and"(.cmp(.first_name, .eql, "Bob"), .cmp(.age, .geq, 42)), .@"and"(.cmp(.age, .eql, 69), .cmp(.last_name, .is_not, "Smith")))) + .where(.@"or"(.@"and"(.@"and"(.cmp(.first_name, .eql, "Bob"), .cmp(.age, .geq, 42)), .cmp(.last_name, .is_not, "Smith")), .cmp(.age, .eql, 69))) + .distinct() + .limit(.{ .count = 25 }); + + var statement = try query.prepare(allocator); + defer statement.deinit(); - _ = query; + // var rows = statement.iterator(); + // + // while (rows.next()) |row| { + // // TODO: row contains row_data,col_idx,col_name + // _ = row; + // } } // test { diff --git a/src/zilch/Env/value.sync-conflict-20261030-190805-2JYANE7.zig b/src/zilch/Env/value.sync-conflict-20261030-190805-2JYANE7.zig new file mode 100644 index 0000000..7ce2ce8 --- /dev/null +++ b/src/zilch/Env/value.sync-conflict-20261030-190805-2JYANE7.zig @@ -0,0 +1,185 @@ +const std = @import("std"); +const Object = @import("../Object.zig"); +const AnyFuture = @import("future.zig").AnyFuture; + +pub fn isString(comptime T: type) bool { + return comptime blk: { + const info = @typeInfo(T); + if (info != .pointer) break :blk false; + + const ptr = &info.pointer; + if (ptr.is_volatile or ptr.is_allowzero) break :blk false; + + if (ptr.size == .slice) { + break :blk ptr.child == u8; + } + + if (ptr.size == .one) { + const child = @typeInfo(ptr.child); + if (child == .array) { + const arr = &child.array; + break :blk arr.child == u8; + } + } + + break :blk false; + }; +} + +pub fn isObjectRef(comptime T: type) bool { + comptime { + const info = @typeInfo(T); + if (info != .pointer) return false; + + const ptr = &info.pointer; + return ptr.size == .one and @sizeOf(ptr.child) == 0; + } +} + +pub const Value = extern struct { + kind: Kind, + value: extern union { + object: *anyopaque, + string: extern struct { + ptr: [*]const u8, + len: usize, + }, + int: isize, + uint: usize, + float: f64, + undefined: void, + future: usize, + }, + + pub fn from(value: anytype) Value { + const T = @TypeOf(value); + + return switch (T) { + comptime_int => if (value >= 0) .{ + .kind = .uint, + .value = .{ .uint = value }, + } else .{ + .kind = .int, + .value = .{ .int = value }, + }, + usize => .{ + .kind = .uint, + .value = .{ .uint = value }, + }, + isize => .{ + .kind = .int, + .value = .{ .int = value }, + }, + f64, f32, f16 => .{ + .kind = .float, + .value = .{ .float = value }, + }, + void => .{ + .kind = .undefined, + .value = .{ .undefined = {} }, + }, + AnyFuture => .{ + .kind = .future, + .value = .{ .future = value.unresolved.id }, + }, + else => blk: { + if (comptime isString(T)) { + break :blk .{ + .kind = .string, + .value = .{ + .string = .{ + .ptr = @ptrCast(value), + .len = value.len, + }, + }, + }; + } else if (comptime isObjectRef(T)) { + break :blk .{ + .kind = .object, + .value = .{ .object = @ptrCast(value) }, + }; + } else if (@typeInfo(T) == .int) { + // TODO: weil kuscheln mit janina. + } else { + @compileError(std.fmt.comptimePrint( + "cannot auto convert type '{}'.", + .{T}, + )); + } + }, + }; + } + + pub fn unwrap(self: *const Value, T: type) T { + if (Kind.fromType(T) != self.kind) { + std.log.err("unexpected {}, expected {}", .{ self.kind, T }); + @panic("type error"); + } + + return switch (T) { + comptime_int => self.value.int, + usize => self.value.uint, + isize => self.value.int, + f64, f32, f16 => self.value.float, + void => {}, + AnyFuture => @panic("unsupported return type"), + else => blk: { + if (comptime isString(T)) { + break :blk self.value.string.ptr[0..self.value.string.len]; + } else if (comptime isObjectRef(T)) { + break :blk @ptrCast(self.value.object); + } else { + @compileError(std.fmt.comptimePrint( + "cannot auto convert type '{}'.", + .{T}, + )); + } + }, + }; + } + + pub const Kind = enum(u8) { + object = 0, + string = 1, + int = 2, + uint = 3, + float = 4, + undefined = 5, + future = 6, + + pub fn asType(comptime self: Kind) type { + return switch (self) { + .object => return *Object, + .string => return []const u8, + .int => return isize, + .uint => return usize, + .float => f64, + .undefined => return void, + .future => AnyFuture, + }; + } + + pub fn fromType(T: type) Kind { + return switch (T) { + comptime_int => .int, + usize => .uint, + isize => .int, + f64, f32, f16 => .float, + void => .undefined, + AnyFuture => .future, + else => blk: { + if (comptime isString(T)) { + break :blk .string; + } else if (comptime isObjectRef(T)) { + break :blk .object; + } else { + @compileError(std.fmt.comptimePrint( + "cannot auto convert type '{}'.", + .{T}, + )); + } + }, + }; + } + }; +}; diff --git a/src/zilch/app/load.js b/src/zilch/app/load.js index 5cc569f..ed3ab85 100644 --- a/src/zilch/app/load.js +++ b/src/zilch/app/load.js @@ -15,8 +15,8 @@ const imports = { debug(buffer, length) { console.debug(ObjectStore.decodeString(buffer, length)) }, - } -} + }, +}; const wasm_ready = WebAssembly.instantiateStreaming(fetch("index.wasm"), imports).then( ({ instance, module }) => { diff --git a/src/zilch/bridge/root.zig b/src/zilch/bridge/root.zig new file mode 100644 index 0000000..166aadc --- /dev/null +++ b/src/zilch/bridge/root.zig @@ -0,0 +1,40 @@ +const std = @import("std"); +const builtin = @import("builtin"); + +const mod = @import("../root.zig"); +const Env = mod.Env; +const Function = Env.Function; + +const wasm = @import("wasm.root.zig"); +const server = @import("server.root.zig"); + +pub fn Bridge(T: type) type { + if (builtin.target.cpu.arch.isWasm()) { + return wasm.Bridge(T); + } else { + return server.Bridge(T); + } +} + +pub const Context = struct { + gpa: std.mem.Allocator, + arena: std.mem.Allocator, + io: std.Io, +}; + +pub const bindings = struct { + pub const call: Function = .from( + \\async function(ptr, len, result_ptr, len_check) { + \\ const response = await fetch("/api", { + \\ method: "POST", + \\ body: new DateView(wasm.memory.buffer, ptr, len), + \\ }) + \\ const bytes = await response.bytes(); + \\ if (bytes.length != len_check) { + \\ throw "response has incorrect size"; + \\ } + \\ const memory = new Uint8Array(wasm.memory.buffer); + \\ memory.set(bytes, result_ptr); + \\} + ); +}; diff --git a/src/zilch/bridge/server.root.zig b/src/zilch/bridge/server.root.zig new file mode 100644 index 0000000..504286c --- /dev/null +++ b/src/zilch/bridge/server.root.zig @@ -0,0 +1,10 @@ +const std = @import("std"); +const http = @import("http"); + +pub fn Bridge(T: type) type { + _ = T; + return struct { + pub fn handle() void { + } + }; +} diff --git a/src/zilch/bridge/wasm.root.zig b/src/zilch/bridge/wasm.root.zig new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/src/zilch/bridge/wasm.root.zig diff --git a/src/zilch/root.zig b/src/zilch/root.zig index e6112ae..bf0f1ad 100644 --- a/src/zilch/root.zig +++ b/src/zilch/root.zig @@ -10,6 +10,8 @@ pub const Value = Env.Value; pub const log = @import("log/root.zig"); pub const html = @import("html/root.zig"); +pub const bridge = @import("bridge/root.zig"); + pub const Object = @import("Object.zig"); pub const Promise = @import("Promise.zig"); pub const Callable = @import("Callable.zig"); |