more join utils tests

Author: tantaman

packages/zql/src/ivm/cap.ts

@@ -38,7 +38,7 @@ interface CapStorage {
  *
  * - No comparator needed (no ordering requirement)
  * - No `start` or `reverse` fetch support
- * - No `#rowHiddenFromFetch` complexity
+ * - No `#rowHiddenFromFetch` complexity (we can defer when adding to the pk set)
  *
  * Cap is used in EXISTS child pipelines where only the count of matching
  * rows matters, not their order. This allows SQLite to skip ORDER BY

packages/zql/src/ivm/join-utils.test.ts

@@ -2,6 +2,9 @@ import {describe, expect, test} from 'vitest';
 import {
   generateWithOverlayUnordered,
   generateWithOverlayNoYieldUnordered,
+  rowEqualsForCompoundKey,
+  isJoinMatch,
+  buildJoinConstraint,
 } from './join-utils.ts';
 import type {Node} from './data.ts';
 import type {SourceSchema} from './schema.ts';
@@ -280,3 +283,100 @@ describe('generateWithOverlayNoYieldUnordered', () => {
     expect(result.map(n => n.row)).toEqual([{id: 1}, {id: 3}]);
   });
 });
+
+describe('rowEqualsForCompoundKey', () => {
+  test('single key match', () => {
+    expect(rowEqualsForCompoundKey({id: 1}, {id: 1}, ['id'])).toBe(true);
+  });
+
+  test('single key mismatch', () => {
+    expect(rowEqualsForCompoundKey({id: 1}, {id: 2}, ['id'])).toBe(false);
+  });
+
+  test('compound key all match', () => {
+    expect(
+      rowEqualsForCompoundKey({a: 1, b: 'x'}, {a: 1, b: 'x'}, ['a', 'b']),
+    ).toBe(true);
+  });
+
+  test('compound key partial mismatch', () => {
+    expect(
+      rowEqualsForCompoundKey({a: 1, b: 'x'}, {a: 1, b: 'y'}, ['a', 'b']),
+    ).toBe(false);
+  });
+
+  test('null equals null (compareValues treats null as a real value)', () => {
+    expect(rowEqualsForCompoundKey({id: null}, {id: null}, ['id'])).toBe(true);
+  });
+
+  test('extra columns ignored', () => {
+    expect(
+      rowEqualsForCompoundKey(
+        {id: 1, val: 'a'},
+        {id: 1, val: 'b'},
+        ['id'],
+      ),
+    ).toBe(true);
+  });
+});
+
+describe('isJoinMatch', () => {
+  test('single key match', () => {
+    expect(isJoinMatch({id: 1}, ['id'], {id: 1}, ['id'])).toBe(true);
+  });
+
+  test('single key mismatch', () => {
+    expect(isJoinMatch({id: 1}, ['id'], {id: 2}, ['id'])).toBe(false);
+  });
+
+  test('compound key match with different column names', () => {
+    expect(
+      isJoinMatch(
+        {a: 1, b: 'x'},
+        ['a', 'b'],
+        {x: 1, y: 'x'},
+        ['x', 'y'],
+      ),
+    ).toBe(true);
+  });
+
+  test('null parent value returns false (SQL NULL semantics)', () => {
+    expect(isJoinMatch({id: null}, ['id'], {id: 1}, ['id'])).toBe(false);
+  });
+
+  test('null child value returns false', () => {
+    expect(isJoinMatch({id: 1}, ['id'], {id: null}, ['id'])).toBe(false);
+  });
+
+  test('both null returns false (unlike rowEqualsForCompoundKey)', () => {
+    expect(isJoinMatch({id: null}, ['id'], {id: null}, ['id'])).toBe(false);
+  });
+});
+
+describe('buildJoinConstraint', () => {
+  test('single key maps value correctly', () => {
+    expect(buildJoinConstraint({id: 1}, ['id'], ['id'])).toEqual({id: 1});
+  });
+
+  test('compound key maps all values', () => {
+    expect(
+      buildJoinConstraint({a: 1, b: 'x'}, ['a', 'b'], ['a', 'b']),
+    ).toEqual({a: 1, b: 'x'});
+  });
+
+  test('null value returns undefined', () => {
+    expect(buildJoinConstraint({id: null}, ['id'], ['id'])).toBeUndefined();
+  });
+
+  test('null in second position returns undefined', () => {
+    expect(
+      buildJoinConstraint({a: 1, b: null}, ['a', 'b'], ['x', 'y']),
+    ).toBeUndefined();
+  });
+
+  test('different source/target key names', () => {
+    expect(
+      buildJoinConstraint({userId: 5, orgId: 10}, ['userId', 'orgId'], ['id', 'org']),
+    ).toEqual({id: 5, org: 10});
+  });
+});