tracker

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