From c03d2ad2cd42ff9df86cd212278ef36e62b772e8 Mon Sep 17 00:00:00 2001 From: DualFroz Date: Sun, 6 Sep 2026 16:46:32 +0200 Subject: [PATCH] feat: expand join --- src/join.zig | 161 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 161 insertions(+) diff --git a/src/join.zig b/src/join.zig index 99fc00f..d7feb7e 100644 --- a/src/join.zig +++ b/src/join.zig @@ -622,3 +622,164 @@ test "innerJoin: rows missing the join field on either side never match" { try testing.expectEqual(@as(i64, 2), joined[0].left.get("__pk").?.int); } +test "innerJoin: empty right table yields zero matches without touching left side output" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var db = try openTestDb(&tmp); + defer db.close(); + + var left = try Table.open(&db, testing.allocator, "left"); + defer left.deinit(); + try left.put(.{ .int = 1 }, &.{.{ .name = "k", .value = .{ .int = 1 } }}); + + var right = try Table.open(&db, testing.allocator, "right"); + defer right.deinit(); + + const joined = try innerJoin(testing.allocator, &left, "k", null, &right, "k", null); + defer freeJoined(testing.allocator, joined); + + try testing.expectEqual(@as(usize, 0), joined.len); +} + +test "innerJoin: one-to-many fan-out duplicates the left row for each right match" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var db = try openTestDb(&tmp); + defer db.close(); + + var left = try Table.open(&db, testing.allocator, "left"); + defer left.deinit(); + try left.put(.{ .int = 1 }, &.{.{ .name = "k", .value = .{ .int = 42 } }}); + + var right = try Table.open(&db, testing.allocator, "right"); + defer right.deinit(); + var i: i64 = 0; + while (i < 5) : (i += 1) { + try right.put(.{ .int = i }, &.{.{ .name = "k", .value = .{ .int = 42 } }}); + } + + const joined = try innerJoin(testing.allocator, &left, "k", null, &right, "k", null); + defer freeJoined(testing.allocator, joined); + + try testing.expectEqual(@as(usize, 5), joined.len); + for (joined) |pair| { + try testing.expectEqual(@as(i64, 1), pair.left.get("__pk").?.int); + } +} + +test "leftOuterJoin: unmatched left row survives with right=null instead of vanishing" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var db = try openTestDb(&tmp); + defer db.close(); + + var customers = try Table.open(&db, testing.allocator, "customers"); + defer customers.deinit(); + try customers.put(.{ .int = 1 }, &.{.{ .name = "name", .value = .{ .text = "alice" } }}); + try customers.put(.{ .int = 2 }, &.{.{ .name = "name", .value = .{ .text = "bob" } }}); // never ordered + + var orders = try Table.open(&db, testing.allocator, "orders"); + defer orders.deinit(); + try orders.put(.{ .int = 100 }, &.{.{ .name = "customer_id", .value = .{ .int = 1 } }}); + + const joined = try leftOuterJoin(testing.allocator, &customers, "__pk", null, &orders, "customer_id", null); + defer freeOuterJoined(testing.allocator, joined); + + try testing.expectEqual(@as(usize, 2), joined.len); + var sawAliceMatched = false; + var sawBobUnmatched = false; + for (joined) |pair| { + const name = pair.left.get("name").?.text; + if (std.mem.eql(u8, name, "alice")) { + try testing.expect(pair.right != null); + sawAliceMatched = true; + } else if (std.mem.eql(u8, name, "bob")) { + try testing.expect(pair.right == null); + sawBobUnmatched = true; + } + } + try testing.expect(sawAliceMatched); + try testing.expect(sawBobUnmatched); +} + +test "leftOuterJoin: index nested-loop join produces identical results to hash join" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var db = try openTestDb(&tmp); + defer db.close(); + + var customers = try Table.open(&db, testing.allocator, "customers"); + defer customers.deinit(); + try customers.put(.{ .int = 1 }, &.{}); + try customers.put(.{ .int = 2 }, &.{}); // no matching order either way + + var orders = try Table.open(&db, testing.allocator, "orders"); + defer orders.deinit(); + try orders.createIndex("customer_id"); + try orders.put(.{ .int = 100 }, &.{.{ .name = "customer_id", .value = .{ .int = 1 } }}); + try orders.put(.{ .int = 101 }, &.{.{ .name = "customer_id", .value = .{ .int = 1 } }}); + + try testing.expect(orders.hasIndex("customer_id")); + + const joined = try leftOuterJoin(testing.allocator, &customers, "__pk", null, &orders, "customer_id", null); + defer freeOuterJoined(testing.allocator, joined); + + // customer 1 matches twice, customer 2 matches zero times but still appears once. + try testing.expectEqual(@as(usize, 3), joined.len); + var unmatchedCount: usize = 0; + for (joined) |pair| { + if (pair.right == null) unmatchedCount += 1; + } + try testing.expectEqual(@as(usize, 1), unmatchedCount); +} + +test "leftOuterJoin: rightPred filtering out the only match still keeps the left row with right=null" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var db = try openTestDb(&tmp); + defer db.close(); + + var customers = try Table.open(&db, testing.allocator, "customers"); + defer customers.deinit(); + try customers.put(.{ .int = 1 }, &.{}); + + var orders = try Table.open(&db, testing.allocator, "orders"); + defer orders.deinit(); + try orders.put(.{ .int = 100 }, &.{ .{ .name = "customer_id", .value = .{ .int = 1 } }, .{ .name = "status", .value = .{ .text = "cancelled" } } }); + + const shippedOnly = Predicate{ .eq = .{ .field = "status", .value = .{ .text = "shipped" } } }; + const joined = try leftOuterJoin(testing.allocator, &customers, "__pk", null, &orders, "customer_id", shippedOnly); + defer freeOuterJoined(testing.allocator, joined); + + try testing.expectEqual(@as(usize, 1), joined.len); + try testing.expect(joined[0].right == null); +} + +test "leftOuterJoin: left row missing the join field entirely still appears once with right=null" { + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + var db = try openTestDb(&tmp); + defer db.close(); + + var left = try Table.open(&db, testing.allocator, "left"); + defer left.deinit(); + try left.put(.{ .int = 1 }, &.{}); // no "k" field at all + try left.put(.{ .int = 2 }, &.{.{ .name = "k", .value = .{ .int = 7 } }}); + + var right = try Table.open(&db, testing.allocator, "right"); + defer right.deinit(); + try right.put(.{ .int = 1 }, &.{.{ .name = "k", .value = .{ .int = 7 } }}); + + const joined = try leftOuterJoin(testing.allocator, &left, "k", null, &right, "k", null); + defer freeOuterJoined(testing.allocator, joined); + + try testing.expectEqual(@as(usize, 2), joined.len); + for (joined) |pair| { + if (pair.left.get("__pk").?.int == 1) { + try testing.expect(pair.right == null); + } else { + try testing.expect(pair.right != null); + } + } +} +