fix(parser): handle SQL Server GO, PG partitions, line comments, schema names

Four bugs surfaced from the multi-dialect test.sql stress file:

- `--` line comments were never stripped (typo: char compared to "--"),
  which silently dropped any CREATE TABLE that followed a comment line.
  `"select"` with quoted reserved-word columns was the visible casualty.
- T-SQL batch separator `GO` glued the next CREATE TABLE onto the prior
  statement, so `crm.Account` and `crm.Invoice` (plus their FK) never
  reached the graph. Standalone `GO` lines are now rewritten to `;`
  after comment stripping.
- PostgreSQL `PARTITION OF` children (`pg_orders_2026_q1`,
  `pg_orders_default`) were producing empty floating nodes -- they're
  physical shards of the parent, not independent entities, so skip them.
- Schema was being stripped from table names, collapsing `app.customer`
  and `crm.customer` into one node. Table names and FK targets now keep
  the qualified form (`schema.table`) end-to-end.

Tests: refresh the existing public.Article assertion and add seven
regressions covering each issue above plus generated-column expressions
with commas and single-PK + inline REFERENCES 1:1 inference.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ystemsrx

src/parser/sql.ts

@@ -37,7 +37,7 @@ const stripSqlComments = (src: string) => {
           out += src[i++];
         }
       }
-    } else if (ch === "-" && src[i + 1] === "--") {
+    } else if (ch === "-" && src[i + 1] === "-") {
       while (i < src.length && src[i] !== "\n") i++;
     } else if (ch === "/" && src[i + 1] === "*") {
       i += 2;
@@ -100,14 +100,31 @@ const splitStatements = (sql: string) => {
   return statements;
 };
 
-const cleanIdentifier = (raw: string) => {
-  const parts = raw
+// 拆解一个可能带 schema 前缀的标识符为各段裸名（去引号 / 去反引号 / 去方括号）。
+const splitIdentifierParts = (raw: string) =>
+  raw
     .split(".")
     .map((p) => p.trim().replace(/^[`"\[]|[`"\]]$/g, ""))
     .filter(Boolean);
+
+// 仅取最末段的裸名（用于列名 —— 列名不会有 schema 前缀）。
+const cleanIdentifier = (raw: string) => {
+  const parts = splitIdentifierParts(raw);
   return parts[parts.length - 1] || raw.trim();
 };
 
+// 保留 schema 的限定名（用于表名与 FK 目标）：`"app"."customer"` -> `app.customer`。
+// 不同 schema 下同名表才不会塌成同一个节点。
+const qualifiedIdentifier = (raw: string) => {
+  const parts = splitIdentifierParts(raw);
+  return parts.length ? parts.join(".") : raw.trim();
+};
+
+// T-SQL 批处理分隔符 GO 单独成行时把它换成 `;`，让后续按 `;` 切分能识别两边。
+// 必须在去掉块/行注释之后做，否则会误伤注释里的 GO。
+const normalizeBatchSeparators = (sql: string) =>
+  sql.replace(/^[\t ]*GO[\t ]*(?:\r?\n|$)/gim, ";\n");
+
 const splitTopLevelComma = (body: string) => {
   const parts: string[] = [];
   let current = "";
@@ -182,7 +199,7 @@ const parseColumnType = (rest: string) => {
 export const parseSQLTables = (sql: string): ParseResult => {
   const tables: ParsedTable[] = [];
   const relationships: ParsedRelationship[] = [];
-  const cleanSql = stripSqlComments(sql).trim();
+  const cleanSql = normalizeBatchSeparators(stripSqlComments(sql)).trim();
 
   splitStatements(cleanSql).forEach((statement) => {
     if (!/^\s*CREATE\s+(?:TEMP(?:ORARY)?\s+)?TABLE/i.test(statement)) return;
@@ -194,7 +211,12 @@ export const parseSQLTables = (sql: string): ParseResult => {
       ),
     );
     if (!tableNameMatch) return;
-    const tableName = cleanIdentifier(tableNameMatch[1]);
+    const tableName = qualifiedIdentifier(tableNameMatch[1]);
+
+    // PostgreSQL 分区子表（`PARTITION OF parent ...`）不是独立实体 —— 它的列、PK、
+    // FK 都继承自父表。强行解析会得到一个空节点漂在图上，干扰阅读。
+    if (/\bPARTITION\s+OF\b/i.test(statement)) return;
+
     const tableBody = extractMainBody(statement);
     if (!tableBody) return;
 
@@ -223,7 +245,7 @@ export const parseSQLTables = (sql: string): ParseResult => {
       if (fkMatch) {
         foreignKeys.push({
           column: cleanIdentifier(fkMatch[1]),
-          referencedTable: cleanIdentifier(fkMatch[2]),
+          referencedTable: qualifiedIdentifier(fkMatch[2]),
           referencedColumn: cleanIdentifier(fkMatch[3]),
         });
         return;
@@ -254,7 +276,7 @@ export const parseSQLTables = (sql: string): ParseResult => {
       if (inlineRef) {
         foreignKeys.push({
           column: columnName,
-          referencedTable: cleanIdentifier(inlineRef[1]),
+          referencedTable: qualifiedIdentifier(inlineRef[1]),
           referencedColumn: cleanIdentifier(inlineRef[2]),
         });
       }

src/test/parser-sql.test.ts

@@ -43,7 +43,7 @@ describe("parseSQLTables", () => {
       );
     `);
 
-    expect(result.tables[0].name).toBe("Article");
+    expect(result.tables[0].name).toBe("public.Article");
     expect(result.tables[0].columns.map((c) => [c.name, c.type])).toEqual([
       ["ArticleID", "UUID"],
       ["AuthorID", "UUID"],
@@ -52,8 +52,8 @@ describe("parseSQLTables", () => {
     ]);
     expect(result.relationships).toEqual([
       {
-        from: "Article",
-        to: "User",
+        from: "public.Article",
+        to: "public.User",
         label: "AuthorID",
         fromCardinality: "N",
         toCardinality: "1",
@@ -158,4 +158,193 @@ describe("parseSQLTables", () => {
       "email",
     ]);
   });
+
+  // Regression: 之前 stripSqlComments 把 `--` 误写成 `--`-vs-`--` 的双字符比较，
+  // 导致行注释从未被剥离，最终行注释后面紧跟的 CREATE TABLE 整体被拒。
+  it("strips -- line comments so trailing CREATE TABLE is parsed", () => {
+    const result = parseSQLTables(`
+      -- prelude noise
+      -- another line that mentions CREATE TABLE on the side
+      CREATE TABLE solo (
+        id INT PRIMARY KEY
+      );
+    `);
+    expect(result.tables).toHaveLength(1);
+    expect(result.tables[0].name).toBe("solo");
+  });
+
+  // Regression: 引号包裹的保留字在前一段以 `--` 注释结尾时会丢失。
+  it("parses quoted reserved-word identifiers (\"select\", \"from\", \"primary\")", () => {
+    const result = parseSQLTables(`
+      -- Reserved-ish identifiers
+      CREATE TABLE "select" (
+        "from" INTEGER NOT NULL,
+        "where" TEXT,
+        "group" TEXT,
+        CONSTRAINT "primary" PRIMARY KEY ("from")
+      );
+    `);
+    expect(result.tables).toHaveLength(1);
+    expect(result.tables[0].name).toBe("select");
+    expect(result.tables[0].columns.map((c) => c.name)).toEqual([
+      "from",
+      "where",
+      "group",
+    ]);
+    expect(result.tables[0].primaryKeys).toEqual(["from"]);
+  });
+
+  // T-SQL 批处理分隔符 GO 不是合法的 ANSI SQL token，但在 SQL Server 脚本里
+  // 极常见。如果 splitter 不识别，GO 之后的 CREATE TABLE 会被并入上一条语句、
+  // 整段被丢弃 —— 之前 crm.Account / crm.Invoice 就是这样消失的。
+  it("treats SQL Server GO as a batch separator", () => {
+    const result = parseSQLTables(`
+      IF SCHEMA_ID(N'crm') IS NULL
+          EXEC(N'CREATE SCHEMA crm');
+      GO
+
+      CREATE TABLE crm.[Account] (
+          account_id BIGINT NOT NULL,
+          [name] NVARCHAR(200) NOT NULL,
+          CONSTRAINT pk_account PRIMARY KEY CLUSTERED (account_id)
+      );
+      GO
+
+      CREATE TABLE crm.Invoice (
+          invoice_id BIGINT NOT NULL,
+          account_id BIGINT NOT NULL,
+          CONSTRAINT pk_invoice PRIMARY KEY (invoice_id),
+          CONSTRAINT fk_invoice_account
+              FOREIGN KEY (account_id)
+              REFERENCES crm.[Account] (account_id)
+      );
+      GO
+    `);
+    expect(result.tables.map((t) => t.name)).toEqual([
+      "crm.Account",
+      "crm.Invoice",
+    ]);
+    expect(result.relationships).toEqual([
+      {
+        from: "crm.Invoice",
+        to: "crm.Account",
+        label: "account_id",
+        fromCardinality: "N",
+        toCardinality: "1",
+      },
+    ]);
+  });
+
+  // PG 的分区子表只是父表的物理分片，没有自己的列定义。强行解析会得到一个
+  // 空节点漂在图上 —— 直接跳过。
+  it("skips PostgreSQL PARTITION OF child tables", () => {
+    const result = parseSQLTables(`
+      CREATE TABLE app.pg_orders (
+        order_id BIGINT NOT NULL,
+        placed_at TIMESTAMPTZ NOT NULL,
+        CONSTRAINT pk_pg_orders PRIMARY KEY (order_id)
+      ) PARTITION BY RANGE (placed_at);
+
+      CREATE TABLE app.pg_orders_2026_q1
+          PARTITION OF app.pg_orders
+          FOR VALUES FROM ('2026-01-01') TO ('2026-04-01');
+
+      CREATE TABLE app.pg_orders_default
+          PARTITION OF app.pg_orders
+          DEFAULT;
+    `);
+    expect(result.tables.map((t) => t.name)).toEqual(["app.pg_orders"]);
+  });
+
+  // schema 必须留在表名里，否则 app.customer 与 crm.customer 会塌成同一节点。
+  // FK 目标也得带 schema，连线才能命中正确的实体。
+  it("preserves schema on table names and FK targets to disambiguate same-named tables", () => {
+    const result = parseSQLTables(`
+      CREATE TABLE app.customer (
+        customer_id BIGINT PRIMARY KEY,
+        email VARCHAR(320)
+      );
+
+      CREATE TABLE crm.customer (
+        customer_id BIGINT PRIMARY KEY,
+        account_id BIGINT NOT NULL,
+        CONSTRAINT fk_crm_customer_account
+          FOREIGN KEY (account_id) REFERENCES crm.account (account_id)
+      );
+
+      CREATE TABLE app.address (
+        address_id BIGINT PRIMARY KEY,
+        customer_id BIGINT NOT NULL,
+        CONSTRAINT fk_address_customer
+          FOREIGN KEY (customer_id) REFERENCES "app"."customer" (customer_id)
+      );
+    `);
+    expect(result.tables.map((t) => t.name)).toEqual([
+      "app.customer",
+      "crm.customer",
+      "app.address",
+    ]);
+    expect(result.relationships).toEqual([
+      {
+        from: "crm.customer",
+        to: "crm.account",
+        label: "account_id",
+        fromCardinality: "N",
+        toCardinality: "1",
+      },
+      {
+        from: "app.address",
+        to: "app.customer",
+        label: "customer_id",
+        fromCardinality: "N",
+        toCardinality: "1",
+      },
+    ]);
+  });
+
+  // GENERATED ALWAYS AS (...) STORED 的表达式可能含逗号 / 括号，splitTopLevelComma
+  // 必须按括号深度走，否则一列会被切成多片然后丢失。
+  it("parses generated columns with comma-bearing expressions", () => {
+    const result = parseSQLTables(`
+      CREATE TABLE app.pg_order_items (
+        order_id BIGINT NOT NULL,
+        line_no INT NOT NULL,
+        quantity INT NOT NULL DEFAULT 1,
+        unit_price NUMERIC(12, 2) NOT NULL,
+        discount NUMERIC(12, 2) NOT NULL DEFAULT 0,
+        line_total NUMERIC(12, 2)
+          GENERATED ALWAYS AS ((quantity * unit_price) - discount) STORED,
+        CONSTRAINT pk_pg_order_items PRIMARY KEY (order_id, line_no)
+      );
+    `);
+    expect(result.tables[0].columns.map((c) => c.name)).toEqual([
+      "order_id",
+      "line_no",
+      "quantity",
+      "unit_price",
+      "discount",
+      "line_total",
+    ]);
+    expect(result.tables[0].primaryKeys).toEqual(["order_id", "line_no"]);
+  });
+
+  // SQLite 的 inline `REFERENCES` + 单列 PK 应当推断为 1:1（FK 列即整张表的
+  // 唯一主键 -> 关系两端都是 "1"）。这是 sql.ts 里的“单列 PK 自动 1:1”规则。
+  it("infers 1:1 from a single-column PK that is also the FK", () => {
+    const result = parseSQLTables(`
+      CREATE TABLE user_profiles (
+        user_id INTEGER PRIMARY KEY REFERENCES users (id),
+        bio TEXT
+      );
+    `);
+    expect(result.relationships).toEqual([
+      {
+        from: "user_profiles",
+        to: "users",
+        label: "user_id",
+        fromCardinality: "1",
+        toCardinality: "1",
+      },
+    ]);
+  });
 });