gitoria

23.9 KB

1. // hl:mpackdb plugin — native shared library (mission 066)
2. // Zig port of mpackdb v1.0.7 (MessagePack DB with binary-search indexes).
3. //
4. // Layout:
5. // msgpack.zig — MessagePack codec (msgpackr-compatible, see D12)
6. // engine.zig — DB engine (MPackDB/IndexManager semantics)
7. // mpackdb.zig — this file: plugin ABI surface
8. //
9. // Exports:
10. // hl_mpackdb_open(path, primaryKey, indexes, compact) → handle
11. // handle ops: insert(record) / find_all() / find_pk(v) /
12. // find_index(field, v) / find_range(field, from, to) /
13. // delete_pk(v) / update_pk(v, record) / count() /
14. // compact() / persist() / last_error() / pk_name()
15. //
16. // The `hl:mpackdb` .hl surface (MPackDB.hl, cursor.hl, server.hl) is the public
17. // API; these ops are its transport.
18. //
19. // Cursors materialize matches eagerly into a per-iterator arena; the runtime
20. // deep-copies each record on next(), and the arena is freed at iterator deinit.
22. const std = @import("std");
23. const api = @import("plugin_api");
24. pub const msgpack = @import("msgpack.zig");
25. pub const engine = @import("engine.zig");
27. const HlValue = api.HlValue;
28. const HlObject = api.HlObject;
29. const HlField = api.HlField;
30. const HlIterator = api.HlIterator;
31. const HlHandle = api.HlHandle;
32. const HlString = api.HlString;
34. // the plugins' allocator (plugin_api.zig): a DebugAllocator here mapped and unmapped every
35. // buffer of a page or more, which the per-operation buffers made a syscall pair per call
36. const gpa = api.allocator;
38. fn hlStr(comptime s: []const u8) HlString {
39. return .{ .ptr = s.ptr, .len = s.len };
40. }
42. // =========================================================================
43. // Path resolution (mission 077, 074 GAP 9)
44. //
45. // CONTRACT — the same one hl:fs got in mission 068: a relative db path resolves
46. // against the MAIN SCRIPT's directory, not the process CWD. `cd /tmp && hybriel
47. // /srv/app/main.hl` must find /srv/app's database, not create a second one in
48. // /tmp. Absolute paths are used as-is. The runtime injects the directory through
49. // the optional plugin hook hl_mpackdb_set_script_dir right after dlopen.
50. // =========================================================================
52. var script_dir: ?[]u8 = null;
54. export fn hl_mpackdb_set_script_dir(ptr: [*]const u8, len: usize) callconv(.c) void {
55. if (script_dir) |old| gpa.free(old);
56. script_dir = gpa.dupe(u8, ptr[0..len]) catch null;
57. }
59. /// Resolve a (possibly relative) db path against the script dir. The returned
60. /// slice is gpa-allocated; caller frees.
61. fn resolvePath(path: []const u8) ?[]u8 {
62. if (path.len == 0 or path[0] == '/') return gpa.dupe(u8, path) catch null;
63. if (script_dir) |sd| return std.fmt.allocPrint(gpa, "{s}/{s}", .{ sd, path }) catch null;
64. return gpa.dupe(u8, path) catch null;
65. }
67. // =========================================================================
68. // HlValue ⇄ msgpack.Value conversion
69. // =========================================================================
71. /// AN EMPTY LIST is marked by its `fields` address (ticket #58) — the runtime's
72. /// contract, stated in native/src/plugin_loader.zig beside the same constant. Zero
73. /// fields alone read back as an empty hybrid, and `tags = []` was stored as a map.
74. const EMPTY_LIST_FIELDS: [*]HlField = @ptrFromInt(0x4C49_5354_0000_0008);
76. fn isEmptyList(obj: *const HlObject) bool {
77. return obj.field_count == 0 and obj.fields == EMPTY_LIST_FIELDS;
78. }
80. /// Hybriel value (as HlObject tree) → msgpack value, allocated in `arena`.
81. /// An HlObject whose keys are exactly the sequence "0".."n-1" (in order)
82. /// becomes a msgpack array; everything else becomes a map. Hybriel null and
83. /// undefined both arrive as hl_null → msgpack nil.
84. fn hlToMsgpack(arena: std.mem.Allocator, v: HlValue) msgpack.Value {
85. switch (v.type) {
86. .hl_null => return .nil,
87. .hl_bool => return .{ .boolean = v.data.boolean },
88. .hl_number => return .{ .number = v.data.number },
89. .hl_string => {
90. const s = v.data.string.ptr[0..v.data.string.len];
91. const copy = arena.dupe(u8, s) catch return .nil;
92. return .{ .str = copy };
93. },
94. .hl_object => {
95. const obj = v.data.object;
96. const fields = obj.fields[0..obj.field_count];
97. // strict numeric sequence "0".."n-1" → array; an empty list carries its
98. // mark (ticket #58), or `tags = []` was stored as an empty map
99. var is_array = fields.len > 0 or isEmptyList(obj);
100. for (fields, 0..) |f, i| {
101. const k = f.key.ptr[0..f.key.len];
102. var buf: [20]u8 = undefined;
103. const expect = std.fmt.bufPrint(&buf, "{d}", .{i}) catch "";
104. if (!std.mem.eql(u8, k, expect)) {
105. is_array = false;
106. break;
107. }
108. }
109. if (is_array) {
110. const items = arena.alloc(msgpack.Value, fields.len) catch return .nil;
111. for (fields, 0..) |f, i| items[i] = hlToMsgpack(arena, f.value);
112. return .{ .array = items };
113. }
114. const entries = arena.alloc(msgpack.Entry, fields.len) catch return .nil;
115. for (fields, 0..) |f, i| {
116. const k = arena.dupe(u8, f.key.ptr[0..f.key.len]) catch return .nil;
117. entries[i] = .{ .key = .{ .str = k }, .value = hlToMsgpack(arena, f.value) };
118. }
119. return .{ .map = entries };
120. },
121. else => return .nil,
122. }
123. }
125. /// msgpack value → HlValue tree allocated in `arena` (no deinit hooks — the
126. /// runtime deep-copies immediately; the arena outlives the call).
127. fn msgpackToHl(arena: std.mem.Allocator, v: msgpack.Value) HlValue {
128. switch (v) {
129. .nil, .undef => return api.makeNull(),
130. .boolean => |b| return api.makeBool(b),
131. .number => |n| return api.makeNumber(n),
132. .str => |s| return api.makeString(s),
133. .bin => |b| return api.makeString(b),
134. .array => |items| {
135. const fields = arena.alloc(HlField, items.len) catch return api.makeNull();
136. for (items, 0..) |it, i| {
137. var buf: [20]u8 = undefined;
138. const k = std.fmt.bufPrint(&buf, "{d}", .{i}) catch "";
139. const key = arena.dupe(u8, k) catch return api.makeNull();
140. fields[i] = .{ .key = .{ .ptr = key.ptr, .len = key.len }, .value = msgpackToHl(arena, it) };
141. }
142. const obj = arena.create(HlObject) catch return api.makeNull();
143. obj.* = .{ .fields = if (items.len == 0) EMPTY_LIST_FIELDS else fields.ptr, .field_count = fields.len, .deinit_fn = null };
144. return api.makeObject(obj);
145. },
146. .map => |entries| {
147. const fields = arena.alloc(HlField, entries.len) catch return api.makeNull();
148. var n: usize = 0;
149. for (entries) |e| {
150. const key: []const u8 = switch (e.key) {
151. .str => |s| s,
152. .number => |num| blk: {
153. var buf: [40]u8 = undefined;
154. const k = engine.jsNumFmt(&buf, num);
155. break :blk arena.dupe(u8, k) catch continue;
156. },
157. else => continue,
158. };
159. fields[n] = .{ .key = .{ .ptr = key.ptr, .len = key.len }, .value = msgpackToHl(arena, e.value) };
160. n += 1;
161. }
162. const obj = arena.create(HlObject) catch return api.makeNull();
163. obj.* = .{ .fields = fields.ptr, .field_count = n, .deinit_fn = null };
164. return api.makeObject(obj);
165. },
166. .ext => {
167. if (v.timestampMs()) |ms| return api.makeNumber(ms);
168. return api.makeNull();
169. },
170. }
171. }
173. fn hlKey(v: HlValue) ?engine.Key {
174. return switch (v.type) {
175. .hl_number => .{ .num = v.data.number },
176. .hl_string => .{ .str = v.data.string.ptr[0..v.data.string.len] },
177. else => null,
178. };
179. }
181. // =========================================================================
182. // Record iterator (eagerly materialized)
183. // =========================================================================
185. const RecIterState = struct {
186. // THE ITERATOR LIVES IN ITS STATE (the emit soak, 2026-10-02): the runtime frees
187. // only its own wrapper and hands deinit the context, so a separately created
188. // HlIterator was never freed — 40 bytes per find/range/fetch, for good.
189. iter: HlIterator = undefined,
190. arena_state: std.heap.ArenaAllocator,
191. records: []msgpack.Value = &.{},
192. idx: usize = 0,
193. };
195. fn recIterNext(ctx: ?*anyopaque) callconv(.c) HlValue {
196. const state: *RecIterState = @ptrCast(@alignCast(ctx orelse return api.makeNull()));
197. if (state.idx >= state.records.len) {
198. // THE LAST RECORD IS ALREADY COPIED OUT: the arena goes now, not when the
199. // collector sweeps the iterator, which counts none of these bytes and so can
200. // leave thousands of drained lookups' records waiting (hybriel#126, notes)
201. state.records = &.{};
202. _ = state.arena_state.reset(.free_all);
203. return api.makeNull();
204. }
205. const v = state.records[state.idx];
206. state.idx += 1;
207. return msgpackToHl(state.arena_state.allocator(), v);
208. }
210. fn recIterDeinit(ctx: ?*anyopaque) callconv(.c) void {
211. const state: *RecIterState = @ptrCast(@alignCast(ctx orelse return));
212. state.arena_state.deinit();
213. gpa.destroy(state);
214. }
216. fn makeRecordIterator(records: []msgpack.Value, arena_state: std.heap.ArenaAllocator) HlValue {
217. const state = gpa.create(RecIterState) catch return api.makeNull();
218. state.* = .{ .arena_state = arena_state, .records = records };
219. state.iter = .{
220. .context = @ptrCast(state),
221. .next_fn = &recIterNext,
222. .deinit_fn = &recIterDeinitOuter,
223. };
224. return api.makeIterator(&state.iter);
225. }
227. // The runtime's IterWrapper deinit calls iter.deinit_fn then frees its own
228. // wrapper — but the HlIterator struct itself is ours to free.
229. fn recIterDeinitOuter(ctx: ?*anyopaque) callconv(.c) void {
230. recIterDeinit(ctx);
231. }
233. // =========================================================================
234. // DB handle
235. // =========================================================================
236. //
237. // Process-wide table registry (ticket #110). Within one process, a table
238. // path has ONE open engine.Db, shared by every hl_mpackdb_open() on it —
239. // whatever module instance or realm calls it. `hl:mpackdb`'s .so is loaded
240. // once and mapped once by the dynamic linker no matter how many realms
241. // dlopen it (same path, same mapping), so these are already process-wide
242. // statics; the registry just gives multiple opens of the same table a
243. // single Db to share instead of a fresh one each time. A single realm's
244. // event loop drives every call here — mpackdb has never been thread-safe —
245. // so no mutex.
246. //
247. // The file is never compacted or rewritten while a handle on it is live:
248. // only the FIRST open of a path in this process actually runs
249. // engine.Db.open (and so is the only one that can compact-on-open, per
250. // ticket #21's existing rule); every later open of the same path reuses
251. // that live Db untouched, and its own primaryKey/indexes/compact args are
252. // ignored — the table's schema was fixed by the first opener. Compaction
253. // happens only when asked for explicitly (compactNow()) or when the LAST
254. // handle on a path closes.
256. const SharedDb = struct {
257. db: *engine.Db,
258. key: []const u8, // owned; also the registry's stored key for this entry
259. refcount: usize,
260. };
262. var registry: std.StringHashMapUnmanaged(*SharedDb) = .empty;
264. fn acquireShared(path: []const u8, opts: engine.OpenOptions) ?*SharedDb {
265. const key = engine.tableKey(gpa, path) catch return null;
267. if (registry.get(key)) |existing| {
268. gpa.free(key);
269. existing.refcount += 1;
270. return existing;
271. }
273. const db = engine.Db.open(gpa, path, opts) catch |e| {
274. std.debug.print("mpackdb plugin: open failed: {s}\n", .{@errorName(e)});
275. gpa.free(key);
276. return null;
277. };
278. const shared = gpa.create(SharedDb) catch {
279. db.close();
280. gpa.free(key);
281. return null;
282. };
283. shared.* = .{ .db = db, .key = key, .refcount = 1 };
284. registry.put(gpa, key, shared) catch {
285. db.close();
286. gpa.destroy(shared);
287. gpa.free(key);
288. return null;
289. };
290. return shared;
291. }
293. /// Drop this handle's reference. On the LAST reference: compact away any
294. /// tombstones (ticket #110 — that's the one moment compaction may run
295. /// implicitly) and close for real.
296. fn releaseShared(shared: *SharedDb) void {
297. shared.refcount -= 1;
298. if (shared.refcount > 0) return;
300. _ = registry.remove(shared.key);
302. if (shared.db.deleted.items.len > 0) {
303. shared.db.compact() catch |e| {
304. std.debug.print("mpackdb plugin: close-compact failed: {s}\n", .{@errorName(e)});
305. };
306. }
307. shared.db.close();
308. gpa.free(shared.key);
309. gpa.destroy(shared);
310. }
312. const DbState = struct {
313. shared: *SharedDb,
314. };
316. export fn hl_mpackdb_open(argc: u32, argv: [*]const HlValue) callconv(.c) HlValue {
317. if (argc < 1 or argv[0].type != .hl_string) return api.makeNull();
318. const raw_path = argv[0].data.string.ptr[0..argv[0].data.string.len];
319. // mission 077: script-relative, like every other path in Hybriel.
320. const path = resolvePath(raw_path) orelse return api.makeNull();
321. defer gpa.free(path);
323. var opts = engine.OpenOptions{};
324. if (argc > 1 and argv[1].type == .hl_string and argv[1].data.string.len > 0) {
325. opts.primary_key = argv[1].data.string.ptr[0..argv[1].data.string.len];
326. }
327. var index_names: [64][]const u8 = undefined;
328. var index_count: usize = 0;
329. if (argc > 2 and argv[2].type == .hl_object) {
330. const obj = argv[2].data.object;
331. for (obj.fields[0..obj.field_count]) |f| {
332. if (f.value.type != .hl_string) continue;
333. if (index_count >= index_names.len) break;
334. index_names[index_count] = f.value.data.string.ptr[0..f.value.data.string.len];
335. index_count += 1;
336. }
337. }
338. opts.indexes = index_names[0..index_count];
339. if (argc > 3 and argv[3].type == .hl_bool) {
340. opts.compact = argv[3].data.boolean;
341. }
343. const shared = acquireShared(path, opts) orelse return api.makeNull();
345. const state = gpa.create(DbState) catch {
346. releaseShared(shared);
347. return api.makeNull();
348. };
349. state.* = .{ .shared = shared };
351. const handle = gpa.create(HlHandle) catch {
352. releaseShared(shared);
353. gpa.destroy(state);
354. return api.makeNull();
355. };
356. handle.* = .{
357. .context = @ptrCast(state),
358. .call_fn = &handleCall,
359. .close_fn = &handleClose,
360. .type_name = hlStr("MPackDB"),
361. };
362. return api.makeHandle(handle);
363. }
365. fn errDeinit(val: *HlValue) callconv(.c) void {
366. if (val.type == .hl_error) {
367. const s = val.data.string;
368. gpa.free(@constCast(s.ptr[0..s.len]));
369. }
370. }
372. /// mission 077 (074 GAP 10): querying a field that carries no index is a
373. /// MISTAKE, not an empty result — mpackdb only answers through binary-searched
374. /// indexes, so `[]` was indistinguishable from "no such record" and hid the
375. /// missing declaration. The message names the field, the op and every index the
376. /// db was actually opened with (insertion order: primary key first).
377. fn makeNoIndexError(db: *engine.Db, op: []const u8, field: []const u8) HlValue {
378. var list: std.ArrayList(u8) = .empty;
379. defer list.deinit(gpa);
380. for (db.idx.keys()) |k| {
381. if (list.items.len > 0) list.appendSlice(gpa, ", ") catch {};
382. list.append(gpa, '\'') catch {};
383. list.appendSlice(gpa, k) catch {};
384. list.append(gpa, '\'') catch {};
385. }
386. const declared = if (list.items.len == 0) "none" else list.items;
387. const msg = std.fmt.allocPrint(
388. gpa,
389. "mpackdb.{s}: no index on field '{s}' — this db is indexed on [{s}]; every query goes through an index (declare it in `indexes` when opening, or query the primary key)",
390. .{ op, field, declared },
391. ) catch return api.makeError("mpackdb: no index on that field");
392. var v = api.makeError(msg);
393. v.deinit_fn = &errDeinit;
394. return v;
395. }
397. fn handleClose(ctx: ?*anyopaque) callconv(.c) void {
398. const state: *DbState = @ptrCast(@alignCast(ctx orelse return));
399. releaseShared(state.shared);
400. gpa.destroy(state);
401. }
403. fn pkStringDeinit(val: *HlValue) callconv(.c) void {
404. if (val.type == .hl_string) {
405. const s = val.data.string;
406. gpa.free(@constCast(s.ptr[0..s.len]));
407. }
408. }
410. fn handleCall(ctx: ?*anyopaque, op: HlString, argc: u32, argv: [*]const HlValue) callconv(.c) HlValue {
411. const state: *DbState = @ptrCast(@alignCast(ctx orelse return api.makeNull()));
412. const db = state.shared.db;
413. const method = op.ptr[0..op.len];
415. if (std.mem.eql(u8, method, "insert")) {
416. if (argc < 1 or argv[0].type != .hl_object) return api.makeNull();
417. var arena_state = std.heap.ArenaAllocator.init(gpa);
418. defer arena_state.deinit();
419. const arena = arena_state.allocator();
420. const rec = hlToMsgpack(arena, argv[0]);
421. if (rec != .map) return api.makeNull();
422. const res = db.insert(arena, rec, false) catch |e| {
423. if (e != error.DuplicateKey) {
424. std.debug.print("mpackdb plugin: insert failed: {s}\n", .{@errorName(e)});
425. db.last_error = std.fmt.bufPrint(&db.last_error_buf, "insert failed: {s}", .{@errorName(e)}) catch "insert failed";
426. }
427. return api.makeNull();
428. };
429. switch (res) {
430. .pk_num => |n| return api.makeNumber(n),
431. .pk_str => |s| {
432. const copy = gpa.dupe(u8, s) catch return api.makeNull();
433. var out = api.makeString(copy);
434. out.deinit_fn = &pkStringDeinit;
435. return out;
436. },
437. .record => return api.makeBool(true),
438. }
439. }
441. if (std.mem.eql(u8, method, "find_all")) {
442. var arena_state = std.heap.ArenaAllocator.init(gpa);
443. const arena = arena_state.allocator();
444. var records: std.ArrayList(msgpack.Value) = .empty;
445. db.refresh();
446. var scanner = engine.Db.Scanner.init(db, arena, true);
447. while (true) {
448. const maybe = scanner.next(arena) catch break;
449. const rec = maybe orelse break;
450. records.append(arena, rec.value) catch break;
451. }
452. scanner.deinit();
453. const slice = records.toOwnedSlice(arena) catch &.{};
454. return makeRecordIterator(@constCast(slice), arena_state);
455. }
457. if (std.mem.eql(u8, method, "find_pk")) {
458. if (argc < 1) return api.makeNull();
459. const key = hlKey(argv[0]) orelse return api.makeNull();
460. var arena_state = std.heap.ArenaAllocator.init(gpa);
461. const arena = arena_state.allocator();
462. var locs: std.ArrayList(engine.Loc) = .empty;
463. db.findPkLocs(arena, key, &locs) catch {
464. arena_state.deinit();
465. return api.makeNull();
466. };
467. return locsToIterator(db, arena_state, locs.items);
468. }
470. if (std.mem.eql(u8, method, "find_index")) {
471. if (argc < 2 or argv[0].type != .hl_string) return api.makeNull();
472. const field = argv[0].data.string.ptr[0..argv[0].data.string.len];
473. const key = hlKey(argv[1]) orelse return api.makeNull();
474. var arena_state = std.heap.ArenaAllocator.init(gpa);
475. const arena = arena_state.allocator();
476. var locs: std.ArrayList(engine.Loc) = .empty;
477. db.findIndexLocs(arena, field, key, &locs) catch |e| {
478. arena_state.deinit();
479. if (e == error.NoSuchIndex) return makeNoIndexError(db, "find", field);
480. return api.makeNull();
481. };
482. return locsToIterator(db, arena_state, locs.items);
483. }
485. if (std.mem.eql(u8, method, "find_range")) {
486. if (argc < 1 or argv[0].type != .hl_string) return api.makeNull();
487. const field = argv[0].data.string.ptr[0..argv[0].data.string.len];
488. const from: ?engine.Key = if (argc > 1) hlKey(argv[1]) else null;
489. const to: ?engine.Key = if (argc > 2) hlKey(argv[2]) else null;
490. var arena_state = std.heap.ArenaAllocator.init(gpa);
491. const arena = arena_state.allocator();
492. var locs: std.ArrayList(engine.Loc) = .empty;
493. db.findRangeLocs(arena, field, from, to, &locs) catch |e| {
494. arena_state.deinit();
495. if (e == error.NoSuchIndex) return makeNoIndexError(db, "range", field);
496. return api.makeNull();
497. };
498. return locsToIterator(db, arena_state, locs.items);
499. }
501. if (std.mem.eql(u8, method, "delete_pk")) {
502. if (argc < 1) return api.makeNull();
503. const key = hlKey(argv[0]) orelse return api.makeNull();
504. var arena_state = std.heap.ArenaAllocator.init(gpa);
505. defer arena_state.deinit();
506. const arena = arena_state.allocator();
507. var deleted: std.ArrayList(msgpack.Value) = .empty;
508. const n = db.deletePk(arena, key, &deleted) catch |e| {
509. std.debug.print("mpackdb plugin: delete failed: {s}\n", .{@errorName(e)});
510. return api.makeNull();
511. };
512. return api.makeNumber(@floatFromInt(n));
513. }
515. if (std.mem.eql(u8, method, "update_pk")) {
516. if (argc < 2 or argv[1].type != .hl_object) return api.makeNull();
517. const key = hlKey(argv[0]) orelse return api.makeNull();
518. var arena_state = std.heap.ArenaAllocator.init(gpa);
519. defer arena_state.deinit();
520. const arena = arena_state.allocator();
521. const rec = hlToMsgpack(arena, argv[1]);
522. if (rec != .map) return api.makeNull();
523. const n = db.updatePk(arena, key, rec) catch |e| {
524. if (e == error.RecordLacksPrimaryKey) {
525. db.last_error = std.fmt.bufPrint(&db.last_error_buf, "update refused: the record carries no '{s}' (update's record must carry the primary key)", .{db.pk orelse ""}) catch "update refused: the record carries no primary key";
526. return api.makeNull();
527. }
528. if (e != error.DuplicateKey) {
529. std.debug.print("mpackdb plugin: update failed: {s}\n", .{@errorName(e)});
530. }
531. return api.makeNull();
532. };
533. return api.makeNumber(@floatFromInt(n));
534. }
536. if (std.mem.eql(u8, method, "count")) {
537. var arena_state = std.heap.ArenaAllocator.init(gpa);
538. defer arena_state.deinit();
539. const arena = arena_state.allocator();
540. db.refresh();
541. var scanner = engine.Db.Scanner.init(db, arena, true);
542. defer scanner.deinit();
543. var n: usize = 0;
544. while (true) {
545. const maybe = scanner.next(arena) catch break;
546. if (maybe == null) break;
547. n += 1;
548. }
549. return api.makeNumber(@floatFromInt(n));
550. }
552. if (std.mem.eql(u8, method, "compact")) {
553. db.compact() catch |e| {
554. std.debug.print("mpackdb plugin: compact failed: {s}\n", .{@errorName(e)});
555. };
556. return api.makeNull();
557. }
559. if (std.mem.eql(u8, method, "persist")) {
560. db.persistNow() catch |e| {
561. std.debug.print("mpackdb plugin: persist failed: {s}\n", .{@errorName(e)});
562. };
563. return api.makeNull();
564. }
566. if (std.mem.eql(u8, method, "last_error")) {
567. return api.makeString(db.last_error);
568. }
570. // The primary key field name with its */@/! prefixes stripped — the .hl
571. // wrapper needs the bare name to route find(field, …) to find_pk.
572. if (std.mem.eql(u8, method, "pk_name")) {
573. const p = db.pk orelse return api.makeNull();
574. return api.makeString(p);
575. }
577. return api.makeNull();
578. }
580. /// Decode records at `locs` into the iterator arena and wrap them.
581. fn locsToIterator(db: *engine.Db, arena_state: std.heap.ArenaAllocator, locs: []const engine.Loc) HlValue {
582. var st = arena_state;
583. const arena = st.allocator();
584. var records: std.ArrayList(msgpack.Value) = .empty;
585. for (locs) |loc| {
586. const rec = db.readAt(arena, loc) catch continue;
587. records.append(arena, rec) catch break;
588. }
589. const slice = records.toOwnedSlice(arena) catch &.{};
590. return makeRecordIterator(@constCast(slice), st);
591. }
593. test {
594. _ = msgpack;
595. _ = engine;
596. }