Restore natural join column validation using prepare() for reliable column metadata

The old resolveColumns used db.exec() which returns [] for 0-row results
in sql.js, losing column metadata. Now uses db.prepare() + getColumnNames()
which always returns column names regardless of row count.

Validation only errors when both sides have resolvable columns
(gracefully skips if either side fails to resolve).

Removed letter-spacing hack on <- (messes up cursor placement).

https://claude.ai/code/session_01TJyw8nESra9cc5RpVUpmt6

Author: claude

src/raHighlight.ts

@@ -120,9 +120,9 @@ export function highlightRA(code: string): string {
     }
 
     // Assignment arrow: ← (already handled above as binary symbol)
-    // Arrow: <- (assignment) — keep both chars for editor alignment, tight letter-spacing
+    // Arrow: <- (assignment) — keep both chars for editor alignment
     if (code[i] === "<" && i + 1 < code.length && code[i + 1] === "-") {
-      result.push(`<span style="${S.assign} letter-spacing: -0.15em;">&lt;-</span>`);
+      result.push(`<span style="${S.assign}">&lt;-</span>`);
       i += 2;
       continue;
     }

src/relationalAlgebra.test.ts

@@ -174,21 +174,27 @@ describe("natural join (⋈)", () => {
     expect(norm(sql)).toContain("NATURAL JOIN");
   });
 
-  it("should produce NATURAL JOIN SQL even without common columns (let SQLite handle it)", () => {
-    const sql = raToSQL("TableA ⋈ TableB");
-    expect(norm(sql)).toContain("NATURAL JOIN");
+  it("should error on impossible natural join when database is provided", () => {
+    const mockDb = {
+      exec: () => [{ columns: [], values: [] }],
+      prepare: (sql: string) => {
+        const cols = sql.includes("TableA") ? ["id", "name"] : ["code", "description"];
+        return { getColumnNames: () => cols, free: () => {} };
+      },
+    };
+
+    expect(() => raToSQL("TableA ⋈ TableB", mockDb)).toThrow(RAError);
+    expect(() => raToSQL("TableA ⋈ TableB", mockDb)).toThrow(/no common columns/i);
   });
 
   it("should not error on valid natural join when database is provided", () => {
     const mockDb = {
-      exec: (sql: string) => {
-        if (sql.includes("Person")) {
-          return [{ columns: ["id", "name", "city"], values: [] }];
-        }
-        if (sql.includes("Student")) {
-          return [{ columns: ["id", "hasDisability"], values: [] }];
-        }
-        return [{ columns: [], values: [] }];
+      exec: () => [{ columns: [], values: [] }],
+      prepare: (sql: string) => {
+        const cols = sql.includes("Person") ? ["id", "name", "city"]
+          : sql.includes("Student") ? ["id", "hasDisability"]
+            : [];
+        return { getColumnNames: () => cols, free: () => {} };
       },
     };
 

src/relationalAlgebra.ts

@@ -1016,12 +1016,23 @@ let subqueryCounter = 0;
  */
 interface DatabaseHandle {
   exec(sql: string): { columns: string[]; values: unknown[][] }[];
+  prepare(sql: string): { getColumnNames(): string[]; free(): void };
 }
 
 /**
  * Resolve the column names produced by a SQL expression using the database.
- * Executes a LIMIT 0 query to get column metadata without fetching data.
+ * Uses prepare() to get column metadata without executing the query.
  */
+function resolveColumns(sql: string, db: DatabaseHandle): string[] {
+  try {
+    const stmt = db.prepare(`SELECT * FROM (${sql}) LIMIT 0`);
+    const cols = stmt.getColumnNames();
+    stmt.free();
+    return cols;
+  } catch {
+    return [];
+  }
+}
 function nodeToSQL(node: RANode, db?: DatabaseHandle): string {
   switch (node.type) {
     case "table":
@@ -1069,6 +1080,20 @@ function nodeToSQL(node: RANode, db?: DatabaseHandle): string {
     case "naturalJoin": {
       const leftSQL = nodeToSQL(node.left, db);
       const rightSQL = nodeToSQL(node.right, db);
+      if (db) {
+        const leftCols = resolveColumns(leftSQL, db);
+        const rightCols = resolveColumns(rightSQL, db);
+        if (leftCols.length > 0 && rightCols.length > 0) {
+          const common = leftCols.filter(c => rightCols.includes(c));
+          if (common.length === 0) {
+            throw new RAError(
+              "Natural join has no common columns between the two relations. " +
+              "Left columns: [" + leftCols.join(", ") + "], Right columns: [" + rightCols.join(", ") + "]. " +
+              "Use a cross product (×) if a cartesian product is intended, or a theta join (⋈[condition]) to specify the join condition."
+            );
+          }
+        }
+      }
       return `SELECT * FROM (${leftSQL}) AS _ra${subqueryCounter++} NATURAL JOIN (${rightSQL}) AS _ra${subqueryCounter++}`;
     }