@enspirit/bmg-js 1.0.0

package/src/operators/_helpers.ts

@@ -0,0 +1,240 @@
+import { OperationalOperand, Relation, RelationOperand, Renaming, RenamingFunc, Tuple, JoinKeys, AttrName } from "@/types";
+import { MemoryRelation } from '@/Relation';
+import { isRelation } from "./isRelation";
+
+const valueKey = (value: unknown): unknown => {
+  if (isRelation(value)) {
+    // For nested relations, convert to sorted array of tuple keys for comparison
+    const tuples = (value as Relation).toArray();
+    const keys = tuples.map(t => tupleKey(t)).sort();
+    return keys;
+  }
+  return value;
+}
+
+/**
+ * Generates a unique string key for a tuple, used for equality comparison and deduplication.
+ * Handles nested relations by converting them to sorted tuple keys.
+ *
+ * @example
+ * tupleKey({ name: 'Alice', age: 30 })
+ * // => '[["age",30],["name","Alice"]]'
+ *
+ * @example
+ * tupleKey({ id: 1, items: Bmg([{ x: 1 }, { x: 2 }]) })
+ * // => '[["id",1],["items",[...]]]' (nested relation converted to sorted keys)
+ */
+export const tupleKey = (tuple: Tuple): string => {
+  const entries = Object.entries(tuple).map(([k, v]) => [k, valueKey(v)]);
+  return JSON.stringify(entries.sort(([a], [b]) => (a as string).localeCompare(b as string)));
+}
+
+/**
+ * Removes duplicate tuples from an array, preserving order of first occurrence.
+ * Uses tupleKey() for equality comparison.
+ *
+ * @example
+ * deduplicate([
+ *   { id: 1, name: 'Alice' },
+ *   { id: 2, name: 'Bob' },
+ *   { id: 1, name: 'Alice' },  // duplicate
+ * ])
+ * // => [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
+ */
+export const deduplicate = (tuples: Tuple[]): Tuple[] => {
+  const seen = new Set<string>();
+  const result: Tuple[] = [];
+  for (const tuple of tuples) {
+    const key = tupleKey(tuple);
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(tuple);
+    }
+  }
+  return result;
+}
+
+/**
+ * Converts a RelationOperand (Relation or Tuple[]) to an OperationalOperand
+ * that provides a uniform interface for iteration and output.
+ *
+ * @example
+ * // With array input, output remains array
+ * const op = toOperationalOperand([{ id: 1 }]);
+ * [...op.tuples()];        // => [{ id: 1 }]
+ * op.output([{ id: 2 }]);  // => [{ id: 2 }]
+ *
+ * @example
+ * // With Relation input, output is a new Relation
+ * const op = toOperationalOperand(Bmg([{ id: 1 }]));
+ * [...op.tuples()];        // => [{ id: 1 }]
+ * op.output([{ id: 2 }]);  // => Bmg([{ id: 2 }])
+ */
+export const toOperationalOperand = (operand: RelationOperand): OperationalOperand => {
+  if (Array.isArray(operand)) {
+    return {
+      tuples: () => operand,
+      output: (tuples) => tuples,
+    };
+  } else if (isRelation(operand)) {
+    return {
+      tuples: () => (operand as Relation).toArray(),
+      output: (tuples) => new MemoryRelation(tuples),
+    };
+  } else {
+    throw `Unable to iterate ${operand}`
+  }
+}
+
+/**
+ * Converts a Renaming (object or function) to a RenamingFunc.
+ *
+ * @example
+ * // Object renaming
+ * const fn = toRenamingFunc({ name: 'fullName', age: 'years' });
+ * fn('name');  // => 'fullName'
+ * fn('age');   // => 'years'
+ * fn('other'); // => 'other' (unchanged)
+ *
+ * @example
+ * // Function renaming (passed through)
+ * const fn = toRenamingFunc(attr => attr.toUpperCase());
+ * fn('name'); // => 'NAME'
+ */
+export const toRenamingFunc = (renaming: Renaming): RenamingFunc => {
+  if (typeof(renaming) === 'function') {
+    return renaming;
+  } else {
+    return (attr) => renaming[attr] || attr;
+  }
+}
+
+export const error = (msg: string) => {
+  throw(msg);
+}
+
+// Join helpers
+
+/**
+ * Finds attribute names that exist in both left and right tuple arrays.
+ * Used for natural joins when no explicit keys are provided.
+ *
+ * @example
+ * const left = [{ id: 1, name: 'Alice', city: 'NYC' }];
+ * const right = [{ city: 'NYC', country: 'USA' }];
+ * getCommonAttrs(left, right);
+ * // => ['city']
+ *
+ * @example
+ * const left = [{ a: 1, b: 2 }];
+ * const right = [{ b: 2, c: 3 }];
+ * getCommonAttrs(left, right);
+ * // => ['b']
+ */
+export const getCommonAttrs = (left: Tuple[], right: Tuple[]): AttrName[] => {
+  if (left.length === 0 || right.length === 0) return [];
+  const leftAttrs = new Set(Object.keys(left[0]));
+  const rightAttrs = Object.keys(right[0]);
+  return rightAttrs.filter(attr => leftAttrs.has(attr));
+}
+
+/**
+ * Normalizes JoinKeys to a Record<AttrName, AttrName> mapping left attrs to right attrs.
+ *
+ * @example
+ * // undefined => use common attributes
+ * normalizeKeys(undefined, [{ id: 1, city: 'NYC' }], [{ city: 'NYC' }]);
+ * // => { city: 'city' }
+ *
+ * @example
+ * // Array of common attribute names
+ * normalizeKeys(['city', 'country'], leftTuples, rightTuples);
+ * // => { city: 'city', country: 'country' }
+ *
+ * @example
+ * // Object mapping left attr to right attr
+ * normalizeKeys({ city: 'location' }, leftTuples, rightTuples);
+ * // => { city: 'location' }
+ */
+export const normalizeKeys = (keys: JoinKeys | undefined, leftTuples: Tuple[], rightTuples: Tuple[]): Record<AttrName, AttrName> => {
+  if (!keys) {
+    const common = getCommonAttrs(leftTuples, rightTuples);
+    return common.reduce((acc, attr) => {
+      acc[attr] = attr;
+      return acc;
+    }, {} as Record<AttrName, AttrName>);
+  }
+  if (Array.isArray(keys)) {
+    return keys.reduce((acc, attr) => {
+      acc[attr] = attr;
+      return acc;
+    }, {} as Record<AttrName, AttrName>);
+  }
+  return keys;
+}
+
+/**
+ * Checks if two tuples match on the specified key mapping.
+ *
+ * @example
+ * const keyMap = { city: 'location' };
+ * tuplesMatch({ id: 1, city: 'NYC' }, { location: 'NYC', pop: 8 }, keyMap);
+ * // => true (left.city === right.location)
+ *
+ * @example
+ * const keyMap = { city: 'city' };
+ * tuplesMatch({ city: 'NYC' }, { city: 'LA' }, keyMap);
+ * // => false
+ */
+export const tuplesMatch = (left: Tuple, right: Tuple, keyMap: Record<AttrName, AttrName>): boolean => {
+  for (const [leftAttr, rightAttr] of Object.entries(keyMap)) {
+    if (left[leftAttr] !== right[rightAttr]) return false;
+  }
+  return true;
+}
+
+/**
+ * Creates a string key from a tuple's join attributes for fast Set-based lookups.
+ * Used by matching/not_matching for efficient semi-join operations.
+ *
+ * @example
+ * const keyMap = { first: 'fname', last: 'lname' };
+ *
+ * // Left side uses left attr names (keys of keyMap)
+ * matchKey({ id: 1, first: 'John', last: 'Doe' }, keyMap, 'left');
+ * // => '"John"|"Doe"'
+ *
+ * // Right side uses right attr names (values of keyMap)
+ * matchKey({ fname: 'John', lname: 'Doe', age: 30 }, keyMap, 'right');
+ * // => '"John"|"Doe"'
+ */
+export const matchKey = (tuple: Tuple, keyMap: Record<AttrName, AttrName>, side: 'left' | 'right'): string => {
+  const attrs = side === 'left' ? Object.keys(keyMap) : Object.values(keyMap);
+  const values = attrs.map(attr => JSON.stringify(tuple[attr]));
+  return values.join('|');
+}
+
+/**
+ * Removes join key attributes from a right tuple when merging.
+ * Used to avoid duplicate columns in join results.
+ *
+ * @example
+ * const keyMap = { city: 'location' };
+ * projectOutKeys({ location: 'NYC', country: 'USA', pop: 8 }, keyMap);
+ * // => { country: 'USA', pop: 8 }  (location removed)
+ *
+ * @example
+ * const keyMap = { a: 'a', b: 'b' };
+ * projectOutKeys({ a: 1, b: 2, c: 3 }, keyMap);
+ * // => { c: 3 }  (a and b removed)
+ */
+export const projectOutKeys = (tuple: Tuple, keyMap: Record<AttrName, AttrName>): Tuple => {
+  const rightKeys = new Set(Object.values(keyMap));
+  const result: Tuple = {};
+  for (const [attr, value] of Object.entries(tuple)) {
+    if (!rightKeys.has(attr)) {
+      result[attr] = value;
+    }
+  }
+  return result;
+}

package/src/operators/allbut.ts

@@ -0,0 +1,19 @@
+import { RelationOperand, AttrName, Tuple } from "../types";
+import { toOperationalOperand, deduplicate } from "./_helpers";
+
+export const allbut = (operand: RelationOperand, attrs: AttrName[]): RelationOperand => {
+  const op = toOperationalOperand(operand);
+  const iterable = op.tuples();
+  const excluded = new Set(attrs);
+  const result: Tuple[] = [];
+  for (const tuple of iterable) {
+    const projected = Object.keys(tuple).reduce((memo, attr) => {
+      if (!excluded.has(attr)) {
+        memo[attr] = tuple[attr];
+      }
+      return memo;
+    }, {} as Tuple);
+    result.push(projected);
+  }
+  return op.output(deduplicate(result));
+}

package/src/operators/autowrap.ts

@@ -0,0 +1,26 @@
+import { AutowrapOptions, RelationOperand, Tuple } from "../types";
+import { toOperationalOperand } from "./_helpers";
+
+export const autowrap = (operand: RelationOperand, options?: AutowrapOptions): RelationOperand => {
+  const sep = options?.separator ?? '_';
+  const op = toOperationalOperand(operand);
+  const iterable = op.tuples();
+  const result: Tuple[] = [];
+
+  for (const tuple of iterable) {
+    const wrapped: Tuple = {};
+    for (const [attr, value] of Object.entries(tuple)) {
+      const parts = attr.split(sep);
+      if (parts.length === 1) {
+        wrapped[attr] = value;
+      } else {
+        const [prefix, ...rest] = parts;
+        wrapped[prefix] = wrapped[prefix] ?? {};
+        (wrapped[prefix] as Tuple)[rest.join(sep)] = value;
+      }
+    }
+    result.push(wrapped);
+  }
+
+  return op.output(result);
+}

package/src/operators/constants.ts

@@ -0,0 +1,12 @@
+import { RelationOperand, Tuple } from "../types";
+import { toOperationalOperand } from "./_helpers";
+
+export const constants = (operand: RelationOperand, consts: Tuple): RelationOperand => {
+  const op = toOperationalOperand(operand);
+  const iterable = op.tuples();
+  const result: Tuple[] = [];
+  for (const tuple of iterable) {
+    result.push({ ...tuple, ...consts });
+  }
+  return op.output(result)
+}

package/src/operators/cross_product.ts

@@ -0,0 +1,20 @@
+import { RelationOperand, Tuple } from "../types";
+import { toOperationalOperand, deduplicate } from "./_helpers";
+
+export const cross_product = (left: RelationOperand, right: RelationOperand): RelationOperand => {
+  const opLeft = toOperationalOperand(left);
+  const opRight = toOperationalOperand(right);
+  const leftTuples = [...opLeft.tuples()];
+  const rightTuples = [...opRight.tuples()];
+  const result: Tuple[] = [];
+
+  for (const l of leftTuples) {
+    for (const r of rightTuples) {
+      result.push({ ...r, ...l });
+    }
+  }
+
+  return opLeft.output(deduplicate(result));
+}
+
+export { cross_product as cross_join };

package/src/operators/exclude.ts

@@ -0,0 +1,14 @@
+import { toPredicateFunc } from "../support/toPredicateFunc";
+import { RelationOperand, Predicate, Tuple } from "../types";
+import { toOperationalOperand } from "./_helpers";
+
+export const exclude = (operand: RelationOperand, p: Predicate): RelationOperand => {
+  const op = toOperationalOperand(operand);
+  const iterable = op.tuples();
+  const f = toPredicateFunc(p)
+  const kept: Tuple[] = [];
+  for (const tuple of iterable) {
+    if (!f(tuple)) kept.push(tuple);
+  }
+  return op.output(kept)
+}

package/src/operators/extend.ts

@@ -0,0 +1,20 @@
+import { RelationOperand, Extension, Tuple } from "../types";
+import { toOperationalOperand } from "./_helpers";
+
+export const extend = (operand: RelationOperand, extension: Extension): RelationOperand => {
+  const op = toOperationalOperand(operand);
+  const iterable = op.tuples();
+  const result: Tuple[] = [];
+  for (const tuple of iterable) {
+    const extended = { ...tuple };
+    for (const [attr, spec] of Object.entries(extension)) {
+      if (typeof spec === 'function') {
+        extended[attr] = spec(tuple);
+      } else {
+        extended[attr] = tuple[spec];
+      }
+    }
+    result.push(extended);
+  }
+  return op.output(result);
+}

package/src/operators/group.ts

@@ -0,0 +1,53 @@
+import { RelationOperand, AttrName, Tuple } from "../types";
+import { toOperationalOperand } from "./_helpers";
+import { MemoryRelation } from "@/Relation";
+
+const groupKey = (tuple: Tuple, byAttrs: AttrName[]): string => {
+  const keyParts = byAttrs.map(attr => JSON.stringify(tuple[attr]));
+  return keyParts.join('|');
+}
+
+const pickAttrs = (tuple: Tuple, attrs: AttrName[]): Tuple => {
+  return attrs.reduce((acc, attr) => {
+    acc[attr] = tuple[attr];
+    return acc;
+  }, {} as Tuple);
+}
+
+export const group = (operand: RelationOperand, attrs: AttrName[], as: AttrName): RelationOperand => {
+  const op = toOperationalOperand(operand);
+  const tuples = [...op.tuples()];
+
+  if (tuples.length === 0) {
+    return op.output([]);
+  }
+
+  // Determine which attributes to keep at the top level (all except grouped ones)
+  const allAttrs = Object.keys(tuples[0]);
+  const groupedSet = new Set(attrs);
+  const byAttrs = allAttrs.filter(a => !groupedSet.has(a));
+
+  // Group tuples
+  const groups = new Map<string, { base: Tuple, nested: Tuple[] }>();
+  for (const tuple of tuples) {
+    const key = groupKey(tuple, byAttrs);
+    if (!groups.has(key)) {
+      groups.set(key, {
+        base: pickAttrs(tuple, byAttrs),
+        nested: []
+      });
+    }
+    groups.get(key)!.nested.push(pickAttrs(tuple, attrs));
+  }
+
+  // Build result with nested relations
+  const result: Tuple[] = [];
+  for (const { base, nested } of groups.values()) {
+    result.push({
+      ...base,
+      [as]: new MemoryRelation(nested)
+    });
+  }
+
+  return op.output(result);
+}

package/src/operators/image.ts

@@ -0,0 +1,27 @@
+import { RelationOperand, JoinKeys, Tuple, AttrName } from "../types";
+import { toOperationalOperand, normalizeKeys, tuplesMatch, projectOutKeys } from "./_helpers";
+import { MemoryRelation } from "@/Relation";
+
+export const image = (left: RelationOperand, right: RelationOperand, as: AttrName, keys?: JoinKeys): RelationOperand => {
+  const opLeft = toOperationalOperand(left);
+  const opRight = toOperationalOperand(right);
+  const leftTuples = [...opLeft.tuples()];
+  const rightTuples = [...opRight.tuples()];
+  const keyMap = normalizeKeys(keys, leftTuples, rightTuples);
+  const result: Tuple[] = [];
+
+  for (const leftTuple of leftTuples) {
+    const matches: Tuple[] = [];
+    for (const rightTuple of rightTuples) {
+      if (tuplesMatch(leftTuple, rightTuple, keyMap)) {
+        matches.push(projectOutKeys(rightTuple, keyMap));
+      }
+    }
+    result.push({
+      ...leftTuple,
+      [as]: new MemoryRelation(matches)
+    });
+  }
+
+  return opLeft.output(result);
+}

package/src/operators/index.ts

@@ -0,0 +1,31 @@
+export * from './restrict'
+export * from './where'
+export * from './exclude'
+export * from './constants'
+export * from './rename'
+export * from './prefix'
+export * from './suffix'
+export * from './project'
+export * from './allbut'
+export * from './extend'
+export * from './union'
+export * from './minus'
+export * from './intersect'
+export * from './matching'
+export * from './not_matching'
+export * from './join'
+export * from './left_join'
+export * from './cross_product'
+export * from './image'
+export * from './summarize'
+export * from './group'
+export * from './ungroup'
+export * from './wrap'
+export * from './unwrap'
+export * from './autowrap'
+export * from './transform'
+
+export * from './isRelation'
+export * from './isEqual'
+export * from './one'
+export * from './yByX'

package/src/operators/intersect.ts

@@ -0,0 +1,24 @@
+import { RelationOperand, Tuple } from "../types";
+import { toOperationalOperand, tupleKey } from "./_helpers";
+
+export const intersect = (left: RelationOperand, right: RelationOperand): RelationOperand => {
+  const opLeft = toOperationalOperand(left);
+  const opRight = toOperationalOperand(right);
+
+  const rightKeys = new Set<string>();
+  for (const tuple of opRight.tuples()) {
+    rightKeys.add(tupleKey(tuple));
+  }
+
+  const seen = new Set<string>();
+  const result: Tuple[] = [];
+  for (const tuple of opLeft.tuples()) {
+    const key = tupleKey(tuple);
+    if (rightKeys.has(key) && !seen.has(key)) {
+      seen.add(key);
+      result.push(tuple);
+    }
+  }
+
+  return opLeft.output(result);
+}

package/src/operators/isEqual.ts

@@ -0,0 +1,29 @@
+import { RelationOperand } from "../types";
+import { toOperationalOperand, tupleKey } from "./_helpers";
+
+export const isEqual = (left: RelationOperand, right: RelationOperand): boolean => {
+  const opLeft = toOperationalOperand(left);
+  const opRight = toOperationalOperand(right);
+
+  const leftKeys = new Set<string>();
+  for (const tuple of opLeft.tuples()) {
+    leftKeys.add(tupleKey(tuple));
+  }
+
+  const rightKeys = new Set<string>();
+  for (const tuple of opRight.tuples()) {
+    rightKeys.add(tupleKey(tuple));
+  }
+
+  if (leftKeys.size !== rightKeys.size) {
+    return false;
+  }
+
+  for (const key of leftKeys) {
+    if (!rightKeys.has(key)) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/operators/isRelation.ts

@@ -0,0 +1,5 @@
+import { MemoryRelation } from "@/Relation";
+
+export const isRelation = (op) => {
+  return op != null && op.constructor === MemoryRelation;
+}

package/src/operators/join.ts

@@ -0,0 +1,25 @@
+import { RelationOperand, JoinKeys, Tuple, AttrName } from "../types";
+import { toOperationalOperand, normalizeKeys, tuplesMatch, projectOutKeys } from "./_helpers";
+
+const mergeTuples = (left: Tuple, right: Tuple, keyMap: Record<AttrName, AttrName>): Tuple => {
+  return { ...left, ...projectOutKeys(right, keyMap) };
+}
+
+export const join = (left: RelationOperand, right: RelationOperand, keys?: JoinKeys): RelationOperand => {
+  const opLeft = toOperationalOperand(left);
+  const opRight = toOperationalOperand(right);
+  const leftTuples = [...opLeft.tuples()];
+  const rightTuples = [...opRight.tuples()];
+  const keyMap = normalizeKeys(keys, leftTuples, rightTuples);
+  const result: Tuple[] = [];
+
+  for (const leftTuple of leftTuples) {
+    for (const rightTuple of rightTuples) {
+      if (tuplesMatch(leftTuple, rightTuple, keyMap)) {
+        result.push(mergeTuples(leftTuple, rightTuple, keyMap));
+      }
+    }
+  }
+
+  return opLeft.output(result);
+}

package/src/operators/left_join.ts

@@ -0,0 +1,41 @@
+import { RelationOperand, JoinKeys, Tuple, AttrName } from "../types";
+import { toOperationalOperand, normalizeKeys, tuplesMatch } from "./_helpers";
+
+const getRightAttrs = (rightTuples: Tuple[], keyMap: Record<AttrName, AttrName>): AttrName[] => {
+  if (rightTuples.length === 0) return [];
+  const rightKeys = new Set(Object.values(keyMap));
+  return Object.keys(rightTuples[0]).filter(attr => !rightKeys.has(attr));
+}
+
+const mergeTuples = (left: Tuple, right: Tuple | null, rightAttrs: AttrName[]): Tuple => {
+  const result = { ...left };
+  for (const attr of rightAttrs) {
+    result[attr] = right ? right[attr] : null;
+  }
+  return result;
+}
+
+export const left_join = (left: RelationOperand, right: RelationOperand, keys?: JoinKeys): RelationOperand => {
+  const opLeft = toOperationalOperand(left);
+  const opRight = toOperationalOperand(right);
+  const leftTuples = [...opLeft.tuples()];
+  const rightTuples = [...opRight.tuples()];
+  const keyMap = normalizeKeys(keys, leftTuples, rightTuples);
+  const rightAttrs = getRightAttrs(rightTuples, keyMap);
+  const result: Tuple[] = [];
+
+  for (const leftTuple of leftTuples) {
+    let matched = false;
+    for (const rightTuple of rightTuples) {
+      if (tuplesMatch(leftTuple, rightTuple, keyMap)) {
+        result.push(mergeTuples(leftTuple, rightTuple, rightAttrs));
+        matched = true;
+      }
+    }
+    if (!matched) {
+      result.push(mergeTuples(leftTuple, null, rightAttrs));
+    }
+  }
+
+  return opLeft.output(result);
+}

package/src/operators/matching.ts

@@ -0,0 +1,24 @@
+import { RelationOperand, JoinKeys, Tuple } from "../types";
+import { toOperationalOperand, normalizeKeys, matchKey } from "./_helpers";
+
+export const matching = (left: RelationOperand, right: RelationOperand, keys?: JoinKeys): RelationOperand => {
+  const opLeft = toOperationalOperand(left);
+  const opRight = toOperationalOperand(right);
+  const leftTuples = [...opLeft.tuples()];
+  const rightTuples = [...opRight.tuples()];
+  const keyMap = normalizeKeys(keys, leftTuples, rightTuples);
+
+  const rightKeys = new Set<string>();
+  for (const tuple of rightTuples) {
+    rightKeys.add(matchKey(tuple, keyMap, 'right'));
+  }
+
+  const result: Tuple[] = [];
+  for (const tuple of leftTuples) {
+    if (rightKeys.has(matchKey(tuple, keyMap, 'left'))) {
+      result.push(tuple);
+    }
+  }
+
+  return opLeft.output(result);
+}

package/src/operators/minus.ts

@@ -0,0 +1,24 @@
+import { RelationOperand, Tuple } from "../types";
+import { toOperationalOperand, tupleKey } from "./_helpers";
+
+export const minus = (left: RelationOperand, right: RelationOperand): RelationOperand => {
+  const opLeft = toOperationalOperand(left);
+  const opRight = toOperationalOperand(right);
+
+  const rightKeys = new Set<string>();
+  for (const tuple of opRight.tuples()) {
+    rightKeys.add(tupleKey(tuple));
+  }
+
+  const seen = new Set<string>();
+  const result: Tuple[] = [];
+  for (const tuple of opLeft.tuples()) {
+    const key = tupleKey(tuple);
+    if (!rightKeys.has(key) && !seen.has(key)) {
+      seen.add(key);
+      result.push(tuple);
+    }
+  }
+
+  return opLeft.output(result);
+}

package/src/operators/not_matching.ts

@@ -0,0 +1,24 @@
+import { RelationOperand, JoinKeys, Tuple } from "../types";
+import { toOperationalOperand, normalizeKeys, matchKey } from "./_helpers";
+
+export const not_matching = (left: RelationOperand, right: RelationOperand, keys?: JoinKeys): RelationOperand => {
+  const opLeft = toOperationalOperand(left);
+  const opRight = toOperationalOperand(right);
+  const leftTuples = [...opLeft.tuples()];
+  const rightTuples = [...opRight.tuples()];
+  const keyMap = normalizeKeys(keys, leftTuples, rightTuples);
+
+  const rightKeys = new Set<string>();
+  for (const tuple of rightTuples) {
+    rightKeys.add(matchKey(tuple, keyMap, 'right'));
+  }
+
+  const result: Tuple[] = [];
+  for (const tuple of leftTuples) {
+    if (!rightKeys.has(matchKey(tuple, keyMap, 'left'))) {
+      result.push(tuple);
+    }
+  }
+
+  return opLeft.output(result);
+}