notes

8.5 KB

1. // Cross-compat proof driver (mission 066, acceptance gate for D12):
2. // exercises the Zig mpackdb engine against db files written by the REAL
3. // JS mpackdb v1.0.7 — and writes db files the JS side then verifies.
4. //
5. // Companion JS scripts: testdata/compat/*.mjs (see their headers for setup).
6. //
7. // Usage:
8. // zig run compat_driver.zig -- verify_a <dbfile> # read a JS-written db
9. // zig run compat_driver.zig -- mutate_a <dbfile> # mutate it (JS re-verifies)
10. // zig run compat_driver.zig -- write_b <dbfile> # write a fresh db for JS
11. // zig run compat_driver.zig -- verify_b2 <dbfile> # verify JS-side mutations
13. const std = @import("std");
14. const msgpack = @import("msgpack.zig");
15. const engine = @import("engine.zig");
17. const P = std.debug.print;
19. fn keyStr(s: []const u8) engine.Key {
20. return .{ .str = s };
21. }
22. fn keyNum(n: f64) engine.Key {
23. return .{ .num = n };
24. }
26. fn printValue(v: msgpack.Value) void {
27. switch (v) {
28. .nil => P("null", .{}),
29. .undef => P("undefined", .{}),
30. .boolean => |b| P("{}", .{b}),
31. .number => |n| {
32. var buf: [40]u8 = undefined;
33. P("{s}", .{engine.jsNumFmt(&buf, n)});
34. },
35. .str => |s| P("\"{s}\"", .{s}),
36. .bin => |b| P("<bin {d}>", .{b.len}),
37. .array => |items| {
38. P("[", .{});
39. for (items, 0..) |it, i| {
40. if (i > 0) P(",", .{});
41. printValue(it);
42. }
43. P("]", .{});
44. },
45. .map => |entries| {
46. P("{{", .{});
47. for (entries, 0..) |e, i| {
48. if (i > 0) P(",", .{});
49. printValue(e.key);
50. P(":", .{});
51. printValue(e.value);
52. }
53. P("}}", .{});
54. },
55. .ext => |e| {
56. if (v.timestampMs()) |ms| {
57. var buf: [40]u8 = undefined;
58. P("Date({s})", .{engine.jsNumFmt(&buf, ms)});
59. } else {
60. P("<ext {d} len {d}>", .{ e.type, e.data.len });
61. }
62. },
63. }
64. }
66. fn printRecords(label: []const u8, db: *engine.Db, arena: std.mem.Allocator, locs: []const engine.Loc) !void {
67. P("{s}: {d} record(s)\n", .{ label, locs.len });
68. for (locs) |loc| {
69. const rec = try db.readAt(arena, loc);
70. P(" ", .{});
71. printValue(rec);
72. P("\n", .{});
73. }
74. }
76. pub fn main(init: std.process.Init) !void {
77. const gpa = init.gpa;
78. var arena_state = std.heap.ArenaAllocator.init(gpa);
79. defer arena_state.deinit();
80. const arena = arena_state.allocator();
82. var iter = std.process.Args.Iterator.init(init.minimal.args);
83. _ = iter.next();
84. const cmd = iter.next() orelse {
85. P("usage: compat_driver <verify_a|mutate_a|write_b|verify_b2> <dbfile>\n", .{});
86. return;
87. };
88. const dbfile = iter.next() orelse {
89. P("missing dbfile\n", .{});
90. return;
91. };
93. if (std.mem.eql(u8, cmd, "verify_a")) {
94. // Open the JS-written db WITHOUT compaction so we read its files
95. // (data, indexes, idxstate, meta) exactly as JS persisted them.
96. const db = try engine.Db.open(gpa, dbfile, .{
97. .primary_key = "*id",
98. .indexes = &.{ "email", "*age" },
99. .compact = false,
100. });
101. defer db.close();
103. var locs: std.ArrayList(engine.Loc) = .empty;
104. try db.findPkLocs(arena, keyNum(1), &locs);
105. try printRecords("pk id=1", db, arena, locs.items);
107. var locs2: std.ArrayList(engine.Loc) = .empty;
108. try db.findIndexLocs(arena, "email", keyStr("[email protected]"), &locs2);
109. try printRecords("[email protected]", db, arena, locs2.items);
111. // Carol (id=2) was deleted by JS — her email must yield nothing
112. var locs2b: std.ArrayList(engine.Loc) = .empty;
113. try db.findIndexLocs(arena, "email", keyStr("[email protected]"), &locs2b);
114. P("[email protected] (JS-deleted): {d} record(s)\n", .{locs2b.items.len});
116. var locs3: std.ArrayList(engine.Loc) = .empty;
117. try db.findRangeLocs(arena, "age", keyNum(28), keyNum(40), &locs3);
118. try printRecords("age in [28,40]", db, arena, locs3.items);
120. // deleted record must be invisible
121. var locs4: std.ArrayList(engine.Loc) = .empty;
122. try db.findPkLocs(arena, keyNum(2), &locs4);
123. P("pk id=2 (JS-deleted): {d} record(s)\n", .{locs4.items.len});
125. // full scan count
126. var scanner = engine.Db.Scanner.init(db, arena, true);
127. defer scanner.deinit();
128. var count: usize = 0;
129. while (try scanner.next(arena)) |_| count += 1;
130. P("total live records: {d}\n", .{count});
131. P("nextId: ", .{});
132. var buf: [40]u8 = undefined;
133. P("{s}\n", .{engine.jsNumFmt(&buf, db.next_id)});
134. } else if (std.mem.eql(u8, cmd, "mutate_a")) {
135. const db = try engine.Db.open(gpa, dbfile, .{
136. .primary_key = "*id",
137. .indexes = &.{ "email", "*age" },
138. .compact = false,
139. });
140. defer db.close();
142. // 1) insert a new record — auto id must continue the JS sequence
143. var rec = engine.Db.MutableRecord{};
144. try rec.set(arena, "name", .{ .str = "Ziggy Stardust" });
145. try rec.set(arena, "email", .{ .str = "[email protected]" });
146. try rec.set(arena, "age", .{ .number = 99 });
147. var tags = [_]msgpack.Value{ .{ .str = "zig" }, .{ .str = "native" } };
148. try rec.set(arena, "tags", .{ .array = &tags });
149. const res = try db.insert(arena, rec.toValue(), false);
150. var buf: [40]u8 = undefined;
151. P("inserted id={s}\n", .{engine.jsNumFmt(&buf, res.pk_num)});
153. // 2) update id=0: bump age to 31, KEEP the Date field byte-identical
154. var locs: std.ArrayList(engine.Loc) = .empty;
155. try db.findPkLocs(arena, keyNum(0), &locs);
156. if (locs.items.len != 1) return error.UpdateTargetMissing;
157. const old = try db.readAt(arena, locs.items[0]);
158. var upd = engine.Db.MutableRecord{};
159. for (old.map) |e| try upd.entries.append(arena, e);
160. try upd.set(arena, "age", .{ .number = 31 });
161. const n_upd = try db.updatePk(arena, keyNum(0), upd.toValue());
162. P("updated id=0: {d} record(s), age -> 31\n", .{n_upd});
164. // 3) delete id=3
165. var deleted: std.ArrayList(msgpack.Value) = .empty;
166. const n_del = try db.deletePk(arena, keyNum(3), &deleted);
167. P("deleted id=3: {d} record(s)\n", .{n_del});
168. } else if (std.mem.eql(u8, cmd, "write_b")) {
169. // Fresh Zig-written db with uuid pk + secondary indexes for JS to read.
170. const db = try engine.Db.open(gpa, dbfile, .{
171. .primary_key = "@uuid",
172. .indexes = &.{ "city", "*score" },
173. });
174. defer db.close();
176. const cities = [_][]const u8{ "Klagenfurt", "Helsinki", "Wörgl" };
177. const names = [_][]const u8{ "Ada", "Böb", "Chidi" };
178. const scores = [_]f64{ 12.5, -3, 4294967296 };
179. for (cities, names, scores) |city, name, score| {
180. var rec = engine.Db.MutableRecord{};
181. try rec.set(arena, "name", .{ .str = name });
182. try rec.set(arena, "city", .{ .str = city });
183. try rec.set(arena, "score", .{ .number = score });
184. var nested_entries = [_]msgpack.Entry{
185. .{ .key = .{ .str = "active" }, .value = .{ .boolean = true } },
186. .{ .key = .{ .str = "note" }, .value = .nil },
187. };
188. try rec.set(arena, "meta", .{ .map = &nested_entries });
189. const res = try db.insert(arena, rec.toValue(), false);
190. P("inserted uuid={s} ({s})\n", .{ res.pk_str, name });
191. }
192. } else if (std.mem.eql(u8, cmd, "verify_b2")) {
193. const db = try engine.Db.open(gpa, dbfile, .{
194. .primary_key = "@uuid",
195. .indexes = &.{ "city", "*score" },
196. .compact = false,
197. });
198. defer db.close();
200. // JS inserted a marker record with city "Byrodin"
201. var locs: std.ArrayList(engine.Loc) = .empty;
202. try db.findIndexLocs(arena, "city", keyStr("Byrodin"), &locs);
203. try printRecords("city=Byrodin (JS-inserted)", db, arena, locs.items);
205. // JS deleted "Ada" — city Klagenfurt must be gone
206. var locs2: std.ArrayList(engine.Loc) = .empty;
207. try db.findIndexLocs(arena, "city", keyStr("Klagenfurt"), &locs2);
208. P("city=Klagenfurt (JS-deleted): {d} record(s)\n", .{locs2.items.len});
210. var scanner = engine.Db.Scanner.init(db, arena, true);
211. defer scanner.deinit();
212. var count: usize = 0;
213. while (try scanner.next(arena)) |_| count += 1;
214. P("total live records: {d}\n", .{count});
215. } else {
216. P("unknown command {s}\n", .{cmd});
217. }
218. }