sql-code-graph 1.0.0__tar.gz → 1.0.1__tar.gz

{sql_code_graph-1.0.0 → sql_code_graph-1.0.1}/CHANGELOG.md

@@ -1,3 +1,13 @@
+## v1.0.1 (2026-05-30)
+
+### Fix
+
+- **indexer**: abort immediately on Ctrl-C instead of flushing a partial graph
+
+### Perf
+
+- **parser**: recover 3 once-per-statement lineage regressions from 4234e5d
+
 ## v1.0.0 (2026-05-30)
 
 ### Feat

{sql_code_graph-1.0.0 → sql_code_graph-1.0.1}/CLAUDE.md

@@ -104,6 +104,9 @@ Any refactor that touches [`base.py`](src/sqlcg/parsers/base.py) or [`indexer.py
 | **`body_scope` built once per statement**, reused across all columns | `_extract_column_lineage` | Wide SELECTs (176 cols × 11 joins) took 7 min with per-column qualify; once-per-statement is the fix |
 | **Pure-literal skip** (`if not list(col_expr.find_all(exp.Column)): continue`) | column loop in `_extract_column_lineage` | Literals have no source column; without the skip sg_lineage raises noise E1 errors and wastes time |
 | When `body_scope` is available, **`sources=` is NOT passed to `sg_lineage`** | `sg_kwargs` construction | The scope already embeds full column→table resolution; passing `sources=` would make sg_lineage redundantly re-expand them |
+| When a scope is passed to `sg_lineage`, **`copy=False` + `trim_selects=False` are passed too** | `sg_kwargs` construction | Without `copy=False`, sqlglot deep-copies the whole scope on **every per-column call** → O(cols × scope_size). Regressed in `4234e5d`; measured 28.8s on one 3,344-line file |
+| **`body_scope` is built once per statement BEFORE the column loop** (with a schema-free qualify retry on failure), never lazily inside it | `_extract_column_lineage` | Building it inside the loop re-ran expand+qualify+build_scope for *every* column whenever qualify failed (the failure path). Regressed in `4234e5d` |
+| In the INSERT column-list aliasing path, **`body.copy()` + strip-WITH happen once** before the loop; only the single projection is swapped per column | `_extract_column_lineage` INSERT block | A full-body deepcopy per column is O(cols × body_size). Regressed in `4234e5d` |
 | **`_upsert_parsed_file` uses `upsert_nodes_bulk`/`upsert_edges_bulk`** (Phase A→B→C), never `upsert_node`/`upsert_edge` per row | `indexer.py` `_upsert_parsed_file` | Measured: bulk=181s vs per-node=1020s+ on 1,340-file DWH (~10 execute() calls per file vs ~14,500 total). Commit `4234e5d` accidentally regressed this by rewriting the method during C2 normalization. |
 
 Tests covering these invariants live in [`test_T09_01_qualify_once.py`](tests/unit/test_T09_01_qualify_once.py)
@@ -119,6 +122,15 @@ class, not just the named ones, and uses deterministic op-counts (never wall-clo
 flake by machine speed. A red here means something started scaling — find what, do not raise the
 slack. When adding a new hot-path op that must be once-per-statement, add a counter for it there.
 
+The guard's **call-count** axes alone are not enough: the three `4234e5d` regressions kept call
+counts flat/linear but regressed *per-call cost* (`copy=False` dropped → per-column scope deepcopy),
+the *failure path* (per-column re-qualify only when qualify throws), and a *per-column body copy*
+(INSERT aliasing). A clean fixture stays green because its qualify succeeds and its scope is small.
+The guard therefore also pins these **behaviourally**: scope-path `sg_lineage` must pass `copy=False`;
+a forced qualify failure must not re-qualify per column; the INSERT body must be copied once. When
+adding a hot-path optimization, prefer a behavioural assertion (kwarg present, op once-per-statement)
+over a volume count — volume counts hide inside a too-simple fixture, which is how this shipped in v1.0.0.
+
 - When referring to files in docs or plans, use markdown hyperlinks (e.g. [`schema.py`](src/sqlcg/core/schema.py)) so stale references are immediately visible when file names change.
 - No backward compatibility. Re-index is the migration path.
 - No TODO in the happy path of any feature.

{sql_code_graph-1.0.0 → sql_code_graph-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-code-graph
-Version: 1.0.0
+Version: 1.0.1
 Summary: SQL code graph analyzer and lineage tracer
 Project-URL: Homepage, https://github.com/Warhorze/sql-code-graph
 Project-URL: Repository, https://github.com/Warhorze/sql-code-graph

{sql_code_graph-1.0.0 → sql_code_graph-1.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sql-code-graph"
-version = "1.0.0"
+version = "1.0.1"
 description = "SQL code graph analyzer and lineage tracer"
 readme = "README.md"
 requires-python = ">=3.12"

{sql_code_graph-1.0.0 → sql_code_graph-1.0.1}/src/sqlcg/__init__.py

@@ -1,5 +1,5 @@
 """SQL Code Graph - SQL lineage and dependency analysis tool."""
 
-__version__ = "1.0.0"
+__version__ = "1.0.1"
 
 __all__ = ["__version__"]

{sql_code_graph-1.0.0 → sql_code_graph-1.0.1}/src/sqlcg/cli/commands/index.py

@@ -84,6 +84,35 @@ def index_cmd(  # noqa: B008
     db_path = get_db_path()
     db_path.parent.mkdir(parents=True, exist_ok=True)
 
+    try:
+        _run_index(
+            path=path,
+            dialect=dialect,
+            dbt_manifest=dbt_manifest,
+            timeout_per_file=timeout_per_file,
+            no_ddl=no_ddl,
+            quiet=quiet,
+            batch_size=batch_size,
+            profile=profile,
+        )
+    except KeyboardInterrupt:
+        # The backend context manager (inside _run_index) has already closed the
+        # KuzuDB connection and released the lock by the time we get here.
+        console.print("\n[yellow]Interrupted — no partial graph written. Re-run to index.[/yellow]")
+        raise typer.Exit(130) from None
+
+
+def _run_index(
+    *,
+    path: Path,
+    dialect: str | None,
+    dbt_manifest: Path | None,
+    timeout_per_file: int,
+    no_ddl: bool,
+    quiet: bool,
+    batch_size: int,
+    profile: bool,
+) -> None:
     with get_backend() as backend:
         backend.init_schema()
 

{sql_code_graph-1.0.0 → sql_code_graph-1.0.1}/src/sqlcg/indexer/indexer.py

@@ -251,9 +251,11 @@ class Indexer:
                     _t_pass2_end = time.perf_counter()
 
         except KeyboardInterrupt:
-            logger.info("SIGINT received — flushing pass-1 progress")
-            # pass1_results may be partial; upsert what we have
-            self._upsert_all(pass1_results, db)
+            # Kill workers and abort immediately. A partial pass-1-only result is
+            # an incomplete graph (no cross-file resolution, no star expansion);
+            # writing it would leave a misleading half-index. Re-run `sqlcg index`
+            # to index — re-indexing is the migration path.
+            logger.warning("Interrupted — workers killed; no partial graph written.")
             raise
 
         # Assemble final pass-2 results: start from pass-1, overlay pass-2 where available
@@ -1104,16 +1106,6 @@ class Indexer:
 
         return counts
 
-    def _upsert_all(self, results: list[ParsedFile], db: GraphBackend) -> None:
-        """Upsert all parsed files.
-
-        Args:
-            results: List of ParsedFile objects
-            db: GraphBackend instance
-        """
-        for parsed in results:
-            self._upsert_parsed_file(parsed, db)
-
     def _expand_star_sources(self, db: GraphBackend) -> int:
         """Run the post-ingestion star expansion query.
 

{sql_code_graph-1.0.0 → sql_code_graph-1.0.1}/src/sqlcg/indexer/pool.py

@@ -194,7 +194,14 @@ class HardKillPool:
     ) -> None:
         self._dialect = dialect
         self._schema_aliases: dict[str, str] = schema_aliases or {}
-        self._n = n_workers or os.cpu_count() or 4
+        # Leave 2 logical cores of headroom rather than spawning one worker per
+        # logical core. Parsing is CPU-bound, and the main process also does work
+        # between passes (closure resolution, batched upserts); saturating every
+        # core makes the largest files miss the per-file wall-clock timeout.
+        # Measured on the 1,453-file DWH corpus (after the once-per-statement parser
+        # fixes): cpu_count → 2 timeouts / 186s; cpu_count-2 → 0 timeouts / 131s
+        # (fewer timeouts AND faster, since timed-out files waste work + respawn churn).
+        self._n = n_workers or max(1, (os.cpu_count() or 4) - 2)
         self._ctx = mp.get_context("spawn")
         self._workers: list[_WorkerState] = []
 
@@ -322,6 +329,28 @@ class HardKillPool:
             w.task_start = time.monotonic()
             busy.add(slot)
 
+        try:
+            return self._run_map_loop(
+                tasks, results, busy, kill_counts, _assign, per_task_timeout, on_result, n_tasks
+            )
+        except KeyboardInterrupt:
+            # Workers ignore SIGINT and are CPU-bound, so they will not notice a
+            # graceful SHUTDOWN sentinel until their current parse finishes. On
+            # interrupt the user wants the process gone now — hard-kill outright.
+            self.terminate()
+            raise
+
+    def _run_map_loop(
+        self,
+        tasks: list[dict],
+        results: list[ParsedFile | None],
+        busy: set[int],
+        kill_counts: dict[str, int],
+        _assign: Callable[[int], None],
+        per_task_timeout: float,
+        on_result: Callable[[], None] | None,
+        n_tasks: int,
+    ) -> list[ParsedFile | None]:
         # Initial dispatch: fill all worker slots
         for i in range(min(self._n, n_tasks)):
             _assign(i)
@@ -405,6 +434,31 @@ class HardKillPool:
     # Shutdown
     # ------------------------------------------------------------------
 
+    def terminate(self) -> None:
+        """Immediately SIGKILL every worker without a graceful handshake.
+
+        Unlike :meth:`shutdown`, this sends no ``_SHUTDOWN`` sentinel and does
+        not wait for in-flight parses. Workers ignore SIGINT and are CPU-bound,
+        so a graceful stop would block on the longest running parse; on
+        interrupt we kill outright so the process dies promptly.
+        """
+        for w in self._workers:
+            try:
+                w.conn.close()
+            except Exception:
+                pass
+            try:
+                if w.process.is_alive():
+                    w.process.kill()
+            except Exception:
+                pass
+        for w in self._workers:
+            try:
+                w.process.join(timeout=1)
+            except Exception:
+                pass
+        self._workers.clear()
+
     def shutdown(self) -> None:
         """Gracefully stop all workers, then force-kill any that linger."""
         for w in self._workers:

{sql_code_graph-1.0.0 → sql_code_graph-1.0.1}/src/sqlcg/parsers/base.py

@@ -619,10 +619,6 @@ class SqlParser(ABC):
             else:
                 return LineageExtraction(edges=edges, star_sources=star_sources)
 
-            # Build scope once from the body for all-column reuse (T-05 optimization)
-            # Defer scope building to just before the column loop to ensure sources
-            # are expanded first (avoid rebuilding for each column, but only build
-            # after sources are known)
             body_scope = None
             combined_sources = {**(sources or {})}
 
@@ -644,6 +640,54 @@ class SqlParser(ABC):
                                 key = cte_alias.lower()
                                 combined_sources[key] = cte.this
 
+            # Build body_scope ONCE per statement, before the column loop, and reuse
+            # it for every column (CLAUDE.md invariant: "body_scope built once per
+            # statement"). If schema-qualify fails, retry schema-free so we STILL get
+            # a scope for the copy=False fast path; only if both fail do we fall back
+            # to the per-column sources= path. Building this lazily inside the loop
+            # (regressed in 4234e5d) meant a single qualify failure re-ran
+            # expand+qualify+build_scope for EVERY column → O(N_cols) full-body
+            # deepcopies per statement (measured: 229 qualify calls on one 460-line file).
+            if scope is None:
+                expanded_body = body
+                expand_sources = {
+                    k: v for k, v in (sources or {}).items() if isinstance(v, exp.Query)
+                }
+                if expand_sources:
+                    try:
+                        expanded_body = exp.expand(
+                            body,
+                            expand_sources,  # type: ignore
+                            dialect=self.DIALECT,
+                            copy=True,
+                        )
+                    except Exception:
+                        expanded_body = body
+                try:
+                    qualified_body = qualify(
+                        expanded_body,
+                        dialect=self.DIALECT,
+                        schema=schema,
+                        validate_qualify_columns=False,
+                        identify=False,
+                    )
+                    body_scope = build_scope(qualified_body)
+                except Exception as _qualify_exc:
+                    out.errors.append(
+                        f"col_lineage_skip:qualify_failed:{type(_qualify_exc).__name__}"
+                    )
+                    # Schema-free retry: still yields a scope for the copy=False path.
+                    try:
+                        qualified_body = qualify(
+                            expanded_body,
+                            dialect=self.DIALECT,
+                            validate_qualify_columns=False,
+                            identify=False,
+                        )
+                        body_scope = build_scope(qualified_body)
+                    except Exception:
+                        body_scope = None
+
             # Extract output columns
             for col_expr in col_expressions:
                 # Skip star projections — sg_lineage requires a concrete column name.
@@ -723,53 +767,23 @@ class SqlParser(ABC):
                         continue
 
                 try:
-                    # Build scope on first column for reuse across all columns (T-05 optimization).
-                    # NOTE: We build body_scope locally from the extracted body rather than
-                    # using a pre-built scope from the statement, because CREATE/INSERT statements
-                    # have their scope rooted at the outer statement, but the body passed here
-                    # is the inner SELECT. Reusing the outer scope would produce incorrect
-                    # qualification. The pre-built scope from parse_file would only be useful
-                    # if we had a mechanism to extract the matching inner scope, which is
-                    # complex and not yet implemented (see sprint_06 T-05 deviation for details).
-                    if body_scope is None and scope is None:
-                        try:
-                            # Expand only file-level sources (CTEs, temp tables, CTAS bodies).
-                            expanded_body = body
-                            expand_sources = {
-                                k: v for k, v in (sources or {}).items() if isinstance(v, exp.Query)
-                            }
-                            if expand_sources:
-                                expanded_body = exp.expand(
-                                    body,
-                                    expand_sources,  # type: ignore
-                                    dialect=self.DIALECT,
-                                    copy=True,
-                                )
-
-                            # Qualify the expanded body to prepare for scope building
-                            qualified_body = qualify(
-                                expanded_body,
-                                dialect=self.DIALECT,
-                                schema=schema,
-                                validate_qualify_columns=False,
-                                identify=False,
-                            )
-                            body_scope = build_scope(qualified_body)
-                        except Exception as _qualify_exc:
-                            # qualify() failure is non-fatal: sg_lineage falls back to
-                            # its own qualification. Record for observability.
-                            out.errors.append(
-                                f"col_lineage_skip:qualify_failed:{type(_qualify_exc).__name__}:{_qualify_exc}"
-                            )
-                            body_scope = None
-
                     # When a scope is available it embeds full column→table resolution.
                     # On the qualify-failed fallback path (no scope), pass only the small
                     # set of file-level sources so sg_lineage can resolve CTEs/CTAS bodies.
                     active_scope = scope if scope is not None else body_scope
                     sg_kwargs: dict = {"dialect": self.DIALECT}
                     if active_scope is not None:
+                        # scope= path: the pre-built scope already embeds full
+                        # column→table resolution. copy=False + trim_selects=False
+                        # suppress sqlglot's per-call AST deepcopy and per-column
+                        # trim — neither is needed when the scope is built once and
+                        # reused across all columns. Dropping these (regressed in
+                        # 4234e5d) makes lineage() deepcopy the whole scope per
+                        # column → O(columns × scope_size) (measured: 3.2M deepcopy
+                        # calls / ~3.8s on a 359-line file).
                         sg_kwargs["scope"] = active_scope
+                        sg_kwargs["copy"] = False
+                        sg_kwargs["trim_selects"] = False
                     else:
                         sg_kwargs["sources"] = sources or {}
                     root = sg_lineage(col_name, body, **sg_kwargs)
@@ -912,6 +926,13 @@ class SqlParser(ABC):
             # stops sg_lineage at the CTE name boundary (doesn't expand into bodies).
             if isinstance(stmt, exp.Insert) and isinstance(stmt.this, exp.Schema):
                 insert_cols = [c.name for c in stmt.this.expressions]
+                # Build the WITH-stripped body ONCE before the loop and only swap its
+                # single projection per column (regressed in 4234e5d, which moved the
+                # full-body body.copy() inside the loop → O(N_cols) full-body deepcopies
+                # for wide INSERT ... SELECT). Stripping WITH stops sg_lineage at the CTE
+                # name boundary.
+                body_no_with = body.copy()
+                body_no_with.set("with_", None)
                 for idx, col_expr in enumerate(col_expressions):
                     if idx >= len(insert_cols):
                         break
@@ -920,10 +941,8 @@ class SqlParser(ABC):
                     insert_col = insert_cols[idx]
                     if not insert_col:
                         continue
-                    # Build a patched SELECT: strip WITH, alias the expression with the
-                    # INSERT column name so sg_lineage can trace it.
-                    body_no_with = body.copy()
-                    body_no_with.set("with_", None)
+                    # Patch the shared body with this column's aliased expression so
+                    # sg_lineage can trace it to the INSERT column name.
                     aliased = exp.Alias(this=col_expr.copy(), alias=insert_col)
                     body_no_with.set("expressions", [aliased])
                     patched_sql = body_no_with.sql(dialect=self.DIALECT)

{sql_code_graph-1.0.0 → sql_code_graph-1.0.1}/tests/integration/test_indexer_to_graph.py

@@ -106,8 +106,18 @@ def test_walker_yields_only_sql_files(temp_db):
     assert len(files) >= 3
 
 
-def test_sigint_during_index_flushes_progress(temp_db):
-    """Test that SIGINT during index flushes progress to DB."""
+def test_sigint_during_index_aborts_without_partial_write(temp_db):
+    """SIGINT during indexing must re-raise and write NO partial graph.
+
+    A partial pass-1-only result is an incomplete graph (no cross-file
+    resolution, no star expansion); flushing it would leave a misleading
+    half-index that "keeps going" after the user expects the process to die.
+    The contract is: kill workers, abort, write nothing — re-run to index.
+
+    SIGINT lands in the main process while it blocks in HardKillPool.map
+    (the worker subprocesses ignore SIGINT), so we patch map to raise
+    KeyboardInterrupt — the same point the real interrupt surfaces.
+    """
     from unittest.mock import patch
 
     fixtures_path = Path(__file__).parent.parent / "fixtures" / "synthetic"
@@ -116,29 +126,15 @@ def test_sigint_during_index_flushes_progress(temp_db):
 
     indexer = Indexer()
 
-    # Mock parser.parse_file to raise KeyboardInterrupt after first file
-    call_count = [0]
-
-    def mock_parse_file(file_path, sql):
-        call_count[0] += 1
-        if call_count[0] > 1:
-            raise KeyboardInterrupt("User interrupted")
-        # Return a valid parsed file for the first call
-        from sqlcg.parsers.registry import get_parser
-
-        parser = get_parser(None, None)
-        return parser.parse_file(file_path, sql)
-
-    with patch("sqlcg.parsers.ansi_parser.SqlParser.parse_file", side_effect=mock_parse_file):
-        try:
+    with patch(
+        "sqlcg.indexer.indexer.HardKillPool.map",
+        side_effect=KeyboardInterrupt("User interrupted"),
+    ):
+        with pytest.raises(KeyboardInterrupt):
             indexer.index_repo(fixtures_path, dialect=None, db=temp_db, timeout_per_file=30)
-        except KeyboardInterrupt:
-            pass  # Expected
-
-    # Even with SIGINT, at least the first file should have been upserted
-    # Verify by checking node count > 0
-    result = temp_db.run_read("MATCH (n) RETURN COUNT(*) as count", {})
-    count = result[0]["count"]
 
-    # Should have at least created some nodes from the first file
-    assert count > 0
+    # No indexed content should have been written: no partial flush on interrupt.
+    # (init_schema seeds a schema-version metadata node, so assert on File nodes,
+    # which only the upsert pass — skipped on interrupt — creates.)
+    result = temp_db.run_read("MATCH (f:File) RETURN COUNT(*) as count", {})
+    assert result[0]["count"] == 0

{sql_code_graph-1.0.0 → sql_code_graph-1.0.1}/tests/unit/test_hard_kill_pool.py

@@ -7,6 +7,9 @@ multi-worker logic.  Tests are ordered by increasing complexity.
 from __future__ import annotations
 
 import time
+from unittest.mock import patch
+
+import pytest
 
 from sqlcg.indexer.pool import HardKillPool
 from sqlcg.parsers.base import ParsedFile
@@ -203,3 +206,47 @@ def test_pool_shutdown_terminates_workers():
     # After exit, all processes should have been joined / killed
     for p in procs:
         assert not p.is_alive(), f"Worker pid={p.pid} still alive after shutdown"
+
+
+# ---------------------------------------------------------------------------
+# Scenario E — interrupt (Ctrl-C) hard-kills workers immediately, no hang
+# ---------------------------------------------------------------------------
+
+
+def test_pool_terminate_kills_workers_immediately():
+    """terminate() SIGKILLs every worker without a graceful handshake and
+    clears the worker list."""
+    pool = HardKillPool(None, n_workers=2)
+    pool._spawn_all()
+    procs = [w.process for w in pool._workers]
+    assert all(p.is_alive() for p in procs), "Workers should be alive after spawn"
+
+    pool.terminate()
+
+    assert pool._workers == [], "terminate() must clear the worker list"
+    for p in procs:
+        assert not p.is_alive(), f"Worker pid={p.pid} alive after terminate()"
+
+
+def test_pool_keyboardinterrupt_in_map_terminates_and_reraises(tmp_path):
+    """A KeyboardInterrupt raised in the dispatch loop (where SIGINT lands in the
+    main process) hard-kills all workers and re-raises — it never hangs waiting
+    on in-flight CPU-bound parses."""
+    p = tmp_path / "a.sql"
+    p.write_text("SELECT 1;", encoding="utf-8")
+    tasks = [_fast_task(str(p), "SELECT 1;")]
+
+    pool = HardKillPool(None, n_workers=2)
+    pool._spawn_all()
+    procs = [w.process for w in pool._workers]
+    try:
+        with patch.object(pool, "_run_map_loop", side_effect=KeyboardInterrupt):
+            with pytest.raises(KeyboardInterrupt):
+                pool.map(tasks, per_task_timeout=10.0)
+
+        # map's handler called terminate(): workers dead, list cleared.
+        assert pool._workers == []
+        for proc in procs:
+            assert not proc.is_alive(), f"Worker pid={proc.pid} alive after interrupt"
+    finally:
+        pool.shutdown()  # no-op if terminate already cleared the workers

{sql_code_graph-1.0.0 → sql_code_graph-1.0.1}/tests/unit/test_perf_scaling_guard.py

@@ -43,6 +43,13 @@ class HotOpCounters:
         self.build_scope = 0
         self.qualify = 0
         self.sg_lineage = 0
+        # Behavioural counters added after the v1.0.0 regression (commit 4234e5d
+        # dropped copy=False / moved body.copy() into the loop, and the original
+        # call-count axes above stayed green because they count CALLS, not per-call
+        # cost or the qualify-failure path). These pin the EXACT invariants:
+        self.scope_lineage_calls = 0  # sg_lineage calls that pass a pre-built scope
+        self.scope_without_copy_false = 0  # ...of those, how many omit copy=False
+        self.multi_proj_body_copy = 0  # .copy() of a multi-projection SELECT body
 
 
 @contextmanager
@@ -60,6 +67,7 @@ def count_hot_ops():
     _extract_column_lineage, so it is patched at the source. No single call
     passes through two wrappers — no double counting.
     """
+    import sqlglot.expressions as sqlglot_exp
     import sqlglot.lineage as sqlglot_lin
 
     import sqlcg.parsers.base as base_mod
@@ -70,10 +78,19 @@ def count_hot_ops():
         "lin_lineage": sqlglot_lin.lineage,
         "base_bs": base_mod.build_scope,
         "base_q": base_mod.qualify,
+        "exp_copy": sqlglot_exp.Expression.copy,
     }
 
     def lineage_wrap(*a, **k):
         c.sg_lineage += 1
+        # Invariant (regression #1, commit 4234e5d): when a pre-built scope is
+        # passed, copy=False MUST accompany it, else sqlglot deep-copies the whole
+        # scope per column (O(cols × scope_size)). The call count alone is linear
+        # and would not reveal the dropped kwarg — inspect it directly.
+        if k.get("scope") is not None:
+            c.scope_lineage_calls += 1
+            if k.get("copy") is not False:
+                c.scope_without_copy_false += 1
         return orig["lin_lineage"](*a, **k)
 
     def build_scope_wrap_factory(key):
@@ -90,15 +107,25 @@ def count_hot_ops():
 
         return wrap
 
+    def copy_wrap(self, *a, **k):
+        # Invariant (regression #3): the multi-projection body in the INSERT
+        # column-list aliasing path must be copied ONCE per statement, not per
+        # column. Count copies of a SELECT that still has >1 projection.
+        if isinstance(self, sqlglot_exp.Select) and len(self.expressions) > 1:
+            c.multi_proj_body_copy += 1
+        return orig["exp_copy"](self, *a, **k)
+
     sqlglot_lin.lineage = lineage_wrap
     base_mod.build_scope = build_scope_wrap_factory("base_bs")
     base_mod.qualify = qualify_wrap_factory("base_q")
+    sqlglot_exp.Expression.copy = copy_wrap
     try:
         yield c
     finally:
         sqlglot_lin.lineage = orig["lin_lineage"]
         base_mod.build_scope = orig["base_bs"]
         base_mod.qualify = orig["base_q"]
+        sqlglot_exp.Expression.copy = orig["exp_copy"]
 
 
 def assert_flat(base: int, doubled: int, label: str, slack: int = 2) -> None:
@@ -164,3 +191,77 @@ def test_per_statement_ops_flat_when_columns_double():
     assert_flat(base.qualify, doubled.qualify, "qualify")
     # sg_lineage is legitimately per-column; only bound its slope.
     assert_at_most_linear(base.sg_lineage, doubled.sg_lineage, "sg_lineage")
+
+
+# ---------------------------------------------------------------------------
+# Axis 2 — the v1.0.0 sub-class the call-count axis above could NOT catch.
+# Commit 4234e5d kept call counts flat/linear but (1) dropped copy=False so each
+# scope-path sg_lineage deep-copied the scope, (2) re-qualified per column on the
+# qualify-FAILURE path, and (3) copied the full body per column in the INSERT
+# aliasing path. These three guards pin those exact invariants behaviourally.
+# ---------------------------------------------------------------------------
+
+
+def test_scope_path_sg_lineage_passes_copy_false():
+    """Regression #1: every sg_lineage call that carries a pre-built scope must also
+    pass copy=False. Otherwise sqlglot deep-copies the whole scope per column
+    (O(cols × scope_size); measured 28.8s on one 3,344-line file)."""
+    parser = AnsiParser(SchemaResolver(dialect=None))
+    with count_hot_ops() as c:
+        parser.parse_file(Path("scope.sql"), _wide_insert(COLS_BASE))
+
+    assert c.scope_lineage_calls > 0, (
+        "fixture did not exercise the scope= path; the guard would be vacuously green"
+    )
+    assert c.scope_without_copy_false == 0, (
+        f"{c.scope_without_copy_false} of {c.scope_lineage_calls} scope-path sg_lineage "
+        "calls omitted copy=False — sqlglot will deep-copy the scope per column "
+        "(O(cols × scope_size)). Restore copy=False (CLAUDE.md 'Performance invariants')."
+    )
+
+
+def test_insert_aliasing_body_copied_once_per_statement():
+    """Regression #3: the multi-projection body in the INSERT column-list aliasing
+    path must be copied ONCE per statement, not per column."""
+    parser_base = AnsiParser(SchemaResolver(dialect=None))
+    parser_2x = AnsiParser(SchemaResolver(dialect=None))
+    with count_hot_ops() as base:
+        parser_base.parse_file(Path("base.sql"), _wide_insert(COLS_BASE))
+    with count_hot_ops() as doubled:
+        parser_2x.parse_file(Path("doubled.sql"), _wide_insert(COLS_2X))
+
+    assert base.multi_proj_body_copy >= 1, (
+        "fixture did not exercise the INSERT-aliasing body copy; guard vacuously green"
+    )
+    assert_flat(base.multi_proj_body_copy, doubled.multi_proj_body_copy, "multi_proj_body_copy")
+
+
+def test_qualify_not_retried_per_column_when_it_fails():
+    """Regression #2: when qualify() raises for a statement, the parser must NOT
+    re-run qualify once per column. Build it once before the loop (with a single
+    schema-free retry) and fall through to the per-column sources= path."""
+    import sqlcg.parsers.base as base_mod
+
+    def _count_qualify_calls_when_failing(n_cols: int) -> int:
+        calls = 0
+        orig_q = base_mod.qualify
+
+        def always_raise(*a, **k):
+            nonlocal calls
+            calls += 1
+            raise ValueError("forced qualify failure (test)")
+
+        base_mod.qualify = always_raise
+        try:
+            AnsiParser(SchemaResolver(dialect=None)).parse_file(
+                Path("fail.sql"), _wide_insert(n_cols)
+            )
+        finally:
+            base_mod.qualify = orig_q
+        return calls
+
+    base_calls = _count_qualify_calls_when_failing(COLS_BASE)
+    doubled_calls = _count_qualify_calls_when_failing(COLS_2X)
+
+    assert base_calls >= 1, "fixture did not reach the qualify path"
+    assert_flat(base_calls, doubled_calls, "qualify (on the failure path)")

{sql_code_graph-1.0.0 → sql_code_graph-1.0.1}/uv.lock

@@ -2851,7 +2851,7 @@ wheels = [
 
 [[package]]
 name = "sql-code-graph"
-version = "1.0.0"
+version = "1.0.1"
 source = { editable = "." }
 dependencies = [
     { name = "kuzu" },