Fix CTE reassignment, self-ref, table validation, reference title

- Variable reassignment (A <- ...; A <- ...) now generates versioned
  CTE names (A, A_v2, A_v3) with references rewritten via AST transform
- Self-referential A <- A is a no-op (skipped in CTE generation)
- resolveColumns errors now propagate as RAError (e.g. "Table 'X' does
  not exist") instead of silently returning empty columns
- Reference dialog title: "Relational Algebra Reference"
- 125 tests passing

https://claude.ai/code/session_01TJyw8nESra9cc5RpVUpmt6

Author: claude

src/i18n/ui-strings.ts

@@ -81,7 +81,7 @@ export const uiStrings: Record<string, Record<string, string>> = {
     generatedSQL: "Genererad SQL",
     raParseError: "Relationsalgebra-fel: {{message}}",
     raPlaceholder: "-- Skriv ett relationsalgebrauttryck\n-- Klicka på 'RA-referens' för syntax",
-    raReference: "RA-referens",
+    raReference: "Relationsalgebrareferens",
     raUnaryOps: "Unära operatorer",
     raBinaryOps: "Binära operatorer",
     raColOp: "Operator",
@@ -189,7 +189,7 @@ export const uiStrings: Record<string, Record<string, string>> = {
     generatedSQL: "Generated SQL",
     raParseError: "Relational algebra error: {{message}}",
     raPlaceholder: "-- Write a relational algebra expression\n-- Click 'RA Reference' for syntax",
-    raReference: "RA Reference",
+    raReference: "Relational Algebra Reference",
     raUnaryOps: "Unary Operators",
     raBinaryOps: "Binary Operators",
     raColOp: "Operator",

src/relationalAlgebra.test.ts

@@ -756,4 +756,24 @@ describe("implicit return from last assignment", () => {
     const sql = raToSQL("A <- σ[age > 20](Person)\nA");
     expect(norm(sql)).toContain("SELECT * FROM A");
   });
+
+  it("should handle self-referential A <- A as a no-op", () => {
+    const sql = raToSQL("A <- A");
+    expect(norm(sql)).toBe(norm("SELECT * FROM A"));
+  });
+
+  it("should handle variable reassignment with versioned CTE names", () => {
+    const sql = raToSQL("A <- σ[age > 20](Person)\nA <- π[name](A)\nA");
+    expect(norm(sql)).toContain("WITH A AS");
+    expect(norm(sql)).toContain("A_v2 AS");
+    expect(norm(sql)).toContain("SELECT * FROM A_v2");
+  });
+
+  it("should handle triple reassignment", () => {
+    const sql = raToSQL("X <- Person\nX <- σ[age > 20](X)\nX <- π[name](X)");
+    expect(norm(sql)).toContain("X AS");
+    expect(norm(sql)).toContain("X_v2 AS");
+    expect(norm(sql)).toContain("X_v3 AS");
+    expect(norm(sql)).toContain("SELECT * FROM X_v3");
+  });
 });

src/relationalAlgebra.ts

@@ -1029,8 +1029,15 @@ function resolveColumns(sql: string, db: DatabaseHandle): string[] {
     const cols = stmt.getColumnNames();
     stmt.free();
     return cols;
-  } catch {
-    return [];
+  } catch (e) {
+    // Re-throw table-not-found errors as RAError for better messaging
+    const msg = (e as Error).message || String(e);
+    if (/no such table/i.test(msg)) {
+      const match = msg.match(/no such table:\s*(\S+)/i);
+      throw new RAError(match ? `Table '${match[1]}' does not exist` : msg);
+    }
+    // For other errors (e.g. ambiguous column), let them propagate
+    throw new RAError(msg);
   }
 }
 function nodeToSQL(node: RANode, db?: DatabaseHandle): string {
@@ -1148,23 +1155,88 @@ function nodeToSQL(node: RANode, db?: DatabaseHandle): string {
   }
 }
 
+/**
+ * Rewrite table references in an AST node using a name mapping.
+ * Used to handle variable reassignment (A <- ...; A <- ...) by pointing
+ * references to the correct versioned CTE name.
+ */
+function rewriteTableRefs(node: RANode, nameMap: Record<string, string>): RANode {
+  switch (node.type) {
+    case "table":
+      return nameMap[node.name] ? { type: "table", name: nameMap[node.name] } : node;
+    case "selection":
+      return { ...node, relation: rewriteTableRefs(node.relation, nameMap) };
+    case "projection":
+      return { ...node, relation: rewriteTableRefs(node.relation, nameMap) };
+    case "rename":
+      return { ...node, relation: rewriteTableRefs(node.relation, nameMap) };
+    case "group":
+      return { ...node, relation: rewriteTableRefs(node.relation, nameMap) };
+    case "sort":
+      return { ...node, relation: rewriteTableRefs(node.relation, nameMap) };
+    case "distinct":
+      return { ...node, relation: rewriteTableRefs(node.relation, nameMap) };
+    case "crossProduct":
+    case "naturalJoin":
+    case "union":
+    case "intersect":
+    case "difference":
+    case "division":
+    case "leftSemiJoin":
+    case "rightSemiJoin":
+    case "antiJoin":
+      return { ...node, left: rewriteTableRefs(node.left, nameMap), right: rewriteTableRefs(node.right, nameMap) };
+    case "thetaJoin":
+    case "leftJoin":
+    case "rightJoin":
+    case "fullJoin":
+      return { ...node, left: rewriteTableRefs(node.left, nameMap), right: rewriteTableRefs(node.right, nameMap) };
+    default:
+      return node;
+  }
+}
+
 function programToSQL(program: RAProgram, db?: DatabaseHandle): string {
   if (program.assignments.length === 0) {
     return nodeToSQL(program.result, db);
   }
 
-  // Use CTEs (WITH clauses) for assignments
-  const ctes = program.assignments.map(a => {
-    const sql = nodeToSQL(a.expr, db);
-    // Wrap non-table expressions in SELECT * FROM (...) for CTE compatibility
+  // Use CTEs (WITH clauses) for assignments.
+  // Handle reassignment (A <- ..., A <- ...) by versioning CTE names
+  // and rewriting references in subsequent expressions.
+  const ctes: string[] = [];
+  // Maps variable name -> current CTE name (may be versioned like A_v2)
+  const nameMap: Record<string, string> = {};
+  // Track how many times each name has been assigned
+  const assignCount: Record<string, number> = {};
+
+  for (const a of program.assignments) {
+    if (a.expr.type === "table" && a.expr.name === a.name && !nameMap[a.name]) {
+      // Self-referential assignment (A <- A) where A is a real table — skip, it's a no-op
+      continue;
+    }
+
+    // Rewrite the expression: replace table references with their current CTE aliases
+    const rewrittenExpr = rewriteTableRefs(a.expr, nameMap);
+    const sql = nodeToSQL(rewrittenExpr, db);
     const wrappedSQL = /^\w+$/.test(sql) ? `SELECT * FROM ${sql}` : sql;
-    return `${a.name} AS (${wrappedSQL})`;
-  });
 
-  const resultSQL = nodeToSQL(program.result, db);
-  // Wrap bare table reference in SELECT for the final expression
+    // Determine the CTE name for this assignment
+    assignCount[a.name] = (assignCount[a.name] || 0) + 1;
+    const cteName = assignCount[a.name] > 1 ? `${a.name}_v${assignCount[a.name]}` : a.name;
+    nameMap[a.name] = cteName;
+
+    ctes.push(`${cteName} AS (${wrappedSQL})`);
+  }
+
+  // Rewrite the result expression with final name mappings
+  const rewrittenResult = rewriteTableRefs(program.result, nameMap);
+  const resultSQL = nodeToSQL(rewrittenResult, db);
   const wrappedResult = /^\w+$/.test(resultSQL) ? `SELECT * FROM ${resultSQL}` : resultSQL;
 
+  if (ctes.length === 0) {
+    return wrappedResult;
+  }
   return `WITH ${ctes.join(", ")} ${wrappedResult}`;
 }