sql-code-graph 1.4.0__py3-none-any.whl → 1.4.3__py3-none-any.whl

{sql_code_graph-1.4.0.dist-info → sql_code_graph-1.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-code-graph
-Version: 1.4.0
+Version: 1.4.3
 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.4.0.dist-info → sql_code_graph-1.4.3.dist-info}/RECORD

@@ -1,9 +1,9 @@
-sqlcg/__init__.py,sha256=spIaM-bJwyRvB5fw8VYDKkrB5Lz7cKAgRuvBBgKYX3g,115
+sqlcg/__init__.py,sha256=-pjjoaMnukW9b0-s_OOYNjy46alw_PTB6xzvfSyWjew,115
 sqlcg/__main__.py,sha256=1YoFLcqEgTwYq1J3TbUwpkdG0zeeLIf2fJvwWI-CLFU,109
 sqlcg/cli/__init__.py,sha256=W8fD0LpMq2xm_5WKGNMvJh2WBL1ho5E8hUeAqXQYT1g,28
 sqlcg/cli/main.py,sha256=WmdTjsOlz1ozi2Y3Aq4ezR_FCRl-Lc1YOKw3_d48dlY,1650
 sqlcg/cli/commands/__init__.py,sha256=oSHtr6VD-jNubOjuCQyZj2tBppjMEpQDh-IGQ8of9eA,30
-sqlcg/cli/commands/analyze.py,sha256=YG5N1iYG-ierDgAJ36mFpQ4BMf2yJ4YF-UV7Rx-bmYA,11793
+sqlcg/cli/commands/analyze.py,sha256=_aC5ML3w7YdLi7DL3TFS9OiCEIipuNZxWR6S4peTcn4,12154
 sqlcg/cli/commands/db.py,sha256=TMhPCHRWSo8YmlNnSxmGxrR0_1r3K4e0Bn8unZTkvU4,7248
 sqlcg/cli/commands/find.py,sha256=p5Vyyx-VBk8YDWYQN16UhECh7PIeMaEyCPEcUFcRFlM,2598
 sqlcg/cli/commands/gain.py,sha256=SJU1c51a7MgNbZItqQnaBfOWGnV5xpXQctbew5Dr9BE,9062
@@ -22,8 +22,8 @@ sqlcg/core/freshness.py,sha256=F9jWn2cbFs60jA9ta8KrT6MghD0mzI7SqqKs_Op9AeU,4577
 sqlcg/core/graph_db.py,sha256=eLYdmiqPWrZHtKLFcKgD2aiWZHFU3wrwz6Y0A3d9NcE,8633
 sqlcg/core/jobs.py,sha256=Je-fCdSKRgiSsv1W8SgNAlp36a7t7-pJZ-qKPbka9OE,3298
 sqlcg/core/queries.cypher,sha256=cvPOVe5GUOzJN4bxUvDxNI--xIIP8gm42TR-gUnea4U,4685
-sqlcg/core/queries.py,sha256=jtZR6caLpF0WqqkjncYTlf5L1GN6DZweoM5dNOAB8OY,3043
-sqlcg/core/queries.sql,sha256=75EHoHA5hKz-Xs8g-CCtDXbf3lYFEw_fxghjYU48gUM,7794
+sqlcg/core/queries.py,sha256=DeGrpsh-N8CczapKW5Iw_CPBMOxtWZfusMOhpN4Qn_c,3319
+sqlcg/core/queries.sql,sha256=yRITKvjnWY0e1Sa8me0yFe_FkkIBsk3BQn2l0iqOJ7Q,10768
 sqlcg/core/schema.cypher,sha256=rK5QMhSrzZhuj73NeNXGX6oM-rPPPvxFjex0fEyUvkQ,2859
 sqlcg/core/schema.py,sha256=7fKf314ueIV7-tIkQQUS4O6H-OhlFKFVFFvGFqw_5Xk,1476
 sqlcg/indexer/__init__.py,sha256=Wh20Unz2OHs1oIyWLrpurPAasF0BET2g4iXtNk7mh2U,56
@@ -40,8 +40,8 @@ sqlcg/lineage/schema_resolver.py,sha256=iXt6LYF6UVWsGUpcfbmjmGn9wCgXl721lTGf_8Aa
 sqlcg/metrics/__init__.py,sha256=hLJ6wm4St8qqYwKh3o9QG7lcEt1BEYM31ccqO9tGpIg,133
 sqlcg/metrics/store.py,sha256=KuDtxvyAgug9_KtiSCpvgKM2VZM7VSaI3D11uMLjJJk,10604
 sqlcg/parsers/__init__.py,sha256=AamA8wBbDZV9_zEtZCI4Hyen5UAVKHmBwjTghTt2PZE,785
-sqlcg/parsers/ansi_parser.py,sha256=mGZvijMOMQ4i1BybpwU29a8jnIGViefhy9fxzkSpsRM,17193
-sqlcg/parsers/base.py,sha256=IiOkVsm6jz9-48RqDCXiW-UXAraNxQ4pKXvSA7aolnA,49907
+sqlcg/parsers/ansi_parser.py,sha256=UNousZcTgHmgDzbvqF77hPf8RmTqwz4oo1rk9OMGWz4,17570
+sqlcg/parsers/base.py,sha256=N6uqQWHO2lpzTIWgPqzewAXmij0ikZdNmNVJkIQ8Mr0,54889
 sqlcg/parsers/bigquery_parser.py,sha256=mOnWTfXB_Dp4JwFE1PVYOB6CDPf5nYE0Dea8kJCl9uQ,2827
 sqlcg/parsers/postgres_parser.py,sha256=lYfUpQY6j4Qm7ndXBtXbgPoGzYqYddWt5YeFnWKdA6I,946
 sqlcg/parsers/registry.py,sha256=LXy1F6rqQI6VdxpRvZg_tNpoEucW3mXZHYBMlMONbX4,1496
@@ -50,18 +50,18 @@ sqlcg/parsers/tsql_parser.py,sha256=RRj1pACtAk2tLTDaFWRYF67a0IDvaf5A1YQXWIz0bpQ,
 sqlcg/server/__init__.py,sha256=n4wuNE7xyJIJxJZBtmtdccCMQfvTdF-IqIaZVbC4FC4,35
 sqlcg/server/control.py,sha256=qUcztb_aDhL-_X_Nq4q6uGx17cUlbLnI6vUpoZsEjbo,4506
 sqlcg/server/exceptions.py,sha256=EONw34icOByCTpppSQrvQBW6asc4hfqaGDCAFjv96II,469
-sqlcg/server/models.py,sha256=l7ORy6sbtzBW1y3qVaeLwEukbyAgBkz9S5VIm2q4b24,19378
+sqlcg/server/models.py,sha256=plnBVoV6y6JuU2IHzez0yHfsd5QZ_o977UCacS7A5NA,19693
 sqlcg/server/noise_filter.py,sha256=Ats2FFzmzFKqvQPWvlUzK8mY9pzlUhL4m1s8P_HNnvI,6335
 sqlcg/server/read_client.py,sha256=4v1OOl12HCHp6J14HrcWQApSixvJ0wwE8UIIZ0pzLyw,7808
 sqlcg/server/server.py,sha256=A1soT-hYnAX78X5j97nIjw9oIZCxBejjV6p_tRDIK38,24335
 sqlcg/server/skill.py,sha256=EDvmEgl-LQwCxZ9Lca4lt8zCtkk2cCgh9GLYlGgDA64,12828
-sqlcg/server/tools.py,sha256=Rdl5SXAuePydk8Z12JVx-lNQeAqm3k9R-z0Q4DstCkw,69743
+sqlcg/server/tools.py,sha256=oelzyVydELcD0ePYQMiIdZPqm-GolxD4YxtKUtGSeTU,76744
 sqlcg/server/writer.py,sha256=HH8pW6k1c2pbY4b6g2N87Tx4gNCezYqTLNTlAmsHg2Y,18522
 sqlcg/utils/__init__.py,sha256=--iqt5ThTXmT8Wz7da8hs3n0zDfYPl8P-z5OgRJ_77E,154
 sqlcg/utils/hashing.py,sha256=H25-sYfxHKb3_IERFnHyAIYNiXN470Oqo5sJT_D3YOA,438
 sqlcg/utils/ignore.py,sha256=wJjwa0mjnQ_xJExOUxk25y00g065XmmzJapqV3ifD5o,1151
 sqlcg/utils/logging.py,sha256=u0fCmYsLj9o81vawm3xZTHaw68GQYVm7JxG-gP81u8A,840
-sql_code_graph-1.4.0.dist-info/METADATA,sha256=rjzA7ons9zPtU1rsKtlhdx3z3qJUrVHL7tYfdg1HcrE,14085
-sql_code_graph-1.4.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-sql_code_graph-1.4.0.dist-info/entry_points.txt,sha256=Wfe49sVzV9p4eVFGo5RxcV-frr3HOP0yzzst8JBxQLQ,46
-sql_code_graph-1.4.0.dist-info/RECORD,,
+sql_code_graph-1.4.3.dist-info/METADATA,sha256=a-9uSmKrh5FDurLJg_LFgkaNH8K1_ke-engcyBzhues,14085
+sql_code_graph-1.4.3.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+sql_code_graph-1.4.3.dist-info/entry_points.txt,sha256=Wfe49sVzV9p4eVFGo5RxcV-frr3HOP0yzzst8JBxQLQ,46
+sql_code_graph-1.4.3.dist-info/RECORD,,

sqlcg/__init__.py

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

sqlcg/cli/commands/analyze.py

@@ -139,6 +139,7 @@ def upstream(  # noqa: B008
         console.print("[red]Error: --depth must be between 1 and 100[/red]")
         raise typer.Exit(1)
 
+    ref = ref.lower()  # graph keys are lowercased at index time (C2 normalization)
     sql = _upstream_sql(depth, include_intermediate)
     results = run_read_routed(sql, {"ref": ref})
     if not results and len(ref.split(".")) >= 3:
@@ -175,6 +176,7 @@ def downstream(  # noqa: B008
         console.print("[red]Error: --depth must be between 1 and 100[/red]")
         raise typer.Exit(1)
 
+    ref = ref.lower()  # graph keys are lowercased at index time (C2 normalization)
     sql = _downstream_sql(depth, include_intermediate)
     results = run_read_routed(sql, {"ref": ref})
     if not results and len(ref.split(".")) >= 3:
@@ -291,7 +293,12 @@ def unused(
 
 
 def _bare_ref(ref: str) -> str:
-    """Strip schema prefix from a ref string, keeping table.column."""
+    """Strip schema prefix from a ref string, keeping table.column.
+
+    Lowercases defensively so this is safe to call even if the caller did not
+    first fold the ref — graph keys are lowercased at index time (C2 normalization).
+    """
+    ref = ref.lower()
     parts = ref.split(".")
     if len(parts) >= 3:
         return ".".join(parts[1:])

sqlcg/core/queries.py

@@ -54,9 +54,13 @@ COUNT_STAR_SOURCES_QUERY = _Q["COUNT_STAR_SOURCES"]
 COUNT_STAR_EXPANSIONS_QUERY = _Q["COUNT_STAR_EXPANSIONS"]
 FIND_DEFINITION_QUERY = _Q["FIND_DEFINITION"]
 GET_TABLE_DEFINING_FILES_QUERY = _Q["GET_TABLE_DEFINING_FILES"]
+GET_PRODUCER_FILES_FOR_TABLE_QUERY = _Q["GET_PRODUCER_FILES_FOR_TABLE"]
 GET_TABLE_DIRECT_UPSTREAMS_QUERY = _Q["GET_TABLE_DIRECT_UPSTREAMS"]
 GET_COLUMNS_FOR_TABLE_QUERY = _Q["GET_COLUMNS_FOR_TABLE"]
 GET_TABLES_DEFINED_IN_FILE_QUERY = _Q["GET_TABLES_DEFINED_IN_FILE"]
+GET_TARGET_TABLES_FOR_FILE_QUERY = _Q["GET_TARGET_TABLES_FOR_FILE"]
+GET_TABLE_ADJACENCY_FOR_COLUMNS_QUERY = _Q["GET_TABLE_ADJACENCY_FOR_COLUMNS"]
+GET_TABLE_KINDS_BATCH_QUERY = _Q["GET_TABLE_KINDS_BATCH"]
 ANALYZE_UNUSED_TABLES_QUERY = _Q["ANALYZE_UNUSED_TABLES"]
 HUB_RANKING_QUERY = _Q["HUB_RANKING"]
 DEPENDENT_FILES_OF_TABLES_QUERY = _Q["DEPENDENT_FILES_OF_TABLES"]

sqlcg/core/queries.sql

@@ -172,6 +172,19 @@ JOIN "DEFINED_IN" di ON di.src_key = t.qualified
 JOIN "File" f ON f.path = di.dst_key
 WHERE t.qualified = ?
 
+-- GET_PRODUCER_FILES_FOR_TABLE
+-- ETL INSERT...SELECT producers populate a table without a DEFINED_IN edge
+-- (that edge is DDL-only). Resolve SqlQuery.target_table -> QUERY_DEFINED_IN -> File
+-- so get_definition / get_change_scope can also surface "populated here" producer
+-- files, not just "defined here" DDL files (mirror of GET_TARGET_TABLES_FOR_FILE,
+-- the reverse-direction lookup). table_qualified is stored lowercase.
+-- params: [table_qualified]
+SELECT DISTINCT f.path AS file_path
+FROM "SqlQuery" q
+JOIN "QUERY_DEFINED_IN" qdi ON qdi.src_key = q.id
+JOIN "File" f ON f.path = qdi.dst_key
+WHERE q.target_table = ?
+
 -- GET_TABLE_DIRECT_UPSTREAMS
 -- params: [table_qualified, table_qualified]
 SELECT DISTINCT src.qualified AS upstream_table, f.path AS in_file
@@ -198,6 +211,53 @@ FROM "SqlTable" t
 JOIN "DEFINED_IN" di ON di.src_key = t.qualified
 WHERE di.dst_key = ?
 
+-- GET_TARGET_TABLES_FOR_FILE
+-- ETL INSERT...SELECT producers populate a table without a DEFINED_IN edge
+-- (that edge is DDL-only). Resolve query->file QUERY_DEFINED_IN -> SqlQuery.target_table
+-- so diff_impact can also see "populated here" producers, not just "defined here" DDL.
+-- params: [file_path]
+SELECT DISTINCT q.target_table AS table_qualified
+FROM "SqlQuery" q
+JOIN "QUERY_DEFINED_IN" qdi ON qdi.src_key = q.id
+WHERE qdi.dst_key = ?
+  AND q.target_table <> ''
+
+-- GET_TABLE_ADJACENCY_FOR_COLUMNS
+-- Aggregate table-level producer->consumer adjacency derived from COLUMN_LINEAGE,
+-- restricted to a closure's column-id set (Option A — issue #38 backfill fix).
+-- Replaces the N x GET_TABLE_DIRECT_UPSTREAMS loop with a single query: CTE-wrapped
+-- INSERT...SELECT statements emit no SELECTS_FROM adjacency at all (the real source
+-- table is nested in the CTE child scope and never surfaces into the statement's
+-- top-level sources). The raw COLUMN_LINEAGE topology bridges producer -> consumer
+-- via a TWO-HOP path through the synthetic cte/derived node (producer -> cte ->
+-- consumer, not a parallel direct edge) — this query returns ALL rolled-up table
+-- pairs (including synthetic endpoints); the caller contracts synthetic-node hops
+-- into direct real-table adjacency in one pass over this small edge set (still
+-- ONCE per closure, never per-table/per-column). Also returns each endpoint's
+-- SqlTable.kind so the caller can identify synthetic nodes without a second query.
+-- params: [col_ids, col_ids]
+SELECT DISTINCT
+  src.table_qualified AS upstream_table,
+  ut.kind AS upstream_kind,
+  dst.table_qualified AS downstream_table,
+  dt.kind AS downstream_kind
+FROM "COLUMN_LINEAGE" cl
+JOIN "SqlColumn" src ON src.id = cl.src_key
+JOIN "SqlColumn" dst ON dst.id = cl.dst_key
+LEFT JOIN "SqlTable" ut ON ut.qualified = src.table_qualified
+LEFT JOIN "SqlTable" dt ON dt.qualified = dst.table_qualified
+WHERE cl.src_key = ANY(?)
+  AND cl.dst_key = ANY(?)
+  AND src.table_qualified <> dst.table_qualified
+
+-- GET_TABLE_KINDS_BATCH
+-- Batch lookup of SqlTable.kind for a set of qualified names — the authoritative
+-- marker for synthetic cte/derived nodes (issue #38 synthetic-node-leak fix).
+-- params: [table_qualifieds]
+SELECT t.qualified AS table_qualified, t.kind AS kind
+FROM "SqlTable" t
+WHERE t.qualified = ANY(?)
+
 -- ANALYZE_UNUSED_TABLES
 -- params: []
 SELECT t.qualified AS table_qualified

sqlcg/parsers/ansi_parser.py

@@ -404,14 +404,19 @@ class AnsiParser(SqlParser):
             create_stmt: CREATE expression (must be a TABLE create)
 
         Returns:
-            List of column names in source order (as they appear in the SQL)
+            List of column names in source order (as they appear in the SQL),
+            normalized to lowercase with surrounding double-quotes stripped —
+            identical to ColumnRef.__post_init__ — so DDL columns share node
+            identity with lowercase ETL lineage columns (issue #38 Phase 5).
         """
         columns: list[str] = []
         # Find all ColumnDef nodes in the CREATE statement
         for col_def in create_stmt.find_all(exp.ColumnDef):
             col_name = col_def.this.name if col_def.this else None
             if col_name:
-                columns.append(col_name)
+                if len(col_name) >= 2 and col_name[0] == '"' and col_name[-1] == '"':
+                    col_name = col_name[1:-1]
+                columns.append(col_name.lower())
         return columns
 
     @staticmethod

sqlcg/parsers/base.py

@@ -515,6 +515,32 @@ class SqlParser(ABC):
         _walk(root)
         return edges
 
+    def _table_node_to_ref(self, table_node: Any) -> "TableRef | None":
+        """Convert a sqlglot exp.Table AST node to a TableRef.
+
+        Used by the #49 mis-bind override to enumerate candidate source tables
+        from a CTE body's FROM/JOIN once per CTE body (before the per-projection
+        loop).  Does NOT call qualify/build_scope — preserves the O(1)-per-body
+        perf invariant.
+
+        Schema aliases are applied via _apply_table_alias so the emitted edges
+        carry the canonical (post-alias) table identity.
+
+        Args:
+            table_node: sqlglot.expressions.Table AST node
+
+        Returns:
+            TableRef with catalog/db/name extracted and alias-resolved, or None
+            if the alias resolution returns None (treated as an unresolvable ref).
+        """
+        return self._apply_table_alias(
+            TableRef(
+                catalog=table_node.catalog if table_node.catalog else None,
+                db=table_node.db if table_node.db else None,
+                name=table_node.name if table_node.name else str(table_node),
+            )
+        )
+
     def _lineage_node_to_table_ref(self, node: Any) -> "TableRef | None":
         """Extract a TableRef from a sqlglot LineageNode's source attribute.
 
@@ -987,6 +1013,20 @@ class SqlParser(ABC):
                             # string for every column rather than re-serializing O(N_cols) times.
                             cte_body_sql = cte_body.sql(dialect=self.DIALECT)
 
+                            # Compute the candidate source-table set ONCE per CTE body
+                            # (before the per-projection loop) — never inside it.
+                            # Uses find_all(exp.Table) on the already-built AST; does NOT
+                            # call qualify/build_scope, preserving O(1) per CTE body.
+                            # This set is reused across all projections to detect ambiguity
+                            # (#49 mis-bind override).
+                            cte_source_tables: list[TableRef] = [
+                                ref
+                                for t in cte_body.find_all(exp.Table)
+                                if t.name  # skip anonymous / subquery placeholders
+                                for ref in (self._table_node_to_ref(t),)
+                                if ref is not None
+                            ]
+
                             # For each projection in the CTE, extract lineage.
                             # Only iterate projections from left branch for column names, but pass
                             # entire Union body to sg_lineage so sqlglot resolves both branches.
@@ -1010,6 +1050,48 @@ class SqlParser(ABC):
                                 )
                                 if not cte_col_name or cte_col_name == "*":
                                     continue
+
+                                # #49 mis-bind override: detect bare (unqualified) columns
+                                # in a ≥2-table CTE body.
+                                #
+                                # sqlglot's sg_lineage (called with no schema and no scope)
+                                # re-qualifies the CTE body internally and mis-binds bare
+                                # columns to the last-joined table — emitting a confident
+                                # WRONG edge (confirmed live: bare `m` from fact_daily was
+                                # bound to dim_time). This is not a missing edge; it is an
+                                # incorrect one.
+                                #
+                                # Override: when any bare column appears inside the projection
+                                # expression AND the CTE body has ≥2 source tables, skip
+                                # sg_lineage for this projection and instead emit one
+                                # CTE_PROJECTION_AMBIGUOUS edge per candidate source table
+                                # (confidence=0.5). Over-attribution is the safe failure mode
+                                # for impact analysis; a wrong single edge is not acceptable.
+                                #
+                                # Single-table bodies: no ambiguity; existing path unchanged.
+                                # Qualified columns in any body: no bare columns; existing path.
+                                bare_cols_in_expr = [
+                                    c
+                                    for c in cte_col_expr.find_all(exp.Column)
+                                    if not c.table  # bare = no qualifier
+                                ]
+                                if bare_cols_in_expr and len(cte_source_tables) >= 2:
+                                    # Emit one ambiguous edge per candidate source table.
+                                    # bare_col.name is the column name to attribute;
+                                    # for aggregates/CASE the bare col name is the leaf.
+                                    bare_col_name = bare_cols_in_expr[0].name or cte_col_name
+                                    dst_col_ref = ColumnRef(cte_dst_table, cte_col_name)
+                                    for src_tbl in cte_source_tables:
+                                        edges.append(
+                                            LineageEdge(
+                                                src=ColumnRef(src_tbl, bare_col_name),
+                                                dst=dst_col_ref,
+                                                transform="CTE_PROJECTION_AMBIGUOUS",
+                                                confidence=0.5,
+                                            )
+                                        )
+                                    continue  # skip sg_lineage for this projection
+
                                 try:
                                     # No schema: resolver.as_dict() {table:[cols]} triggers
                                     # sqlglot nesting-level errors on fresh string parses.

sqlcg/server/models.py

@@ -242,6 +242,12 @@ class DefinitionResult(BaseModel):
     duplicate_ddl: bool = Field(
         False, description="True when the same table is defined in more than one file."
     )
+    producer_files: list[str] = Field(
+        default_factory=list,
+        description="Files whose INSERT...SELECT populates this table (via "
+        "QUERY_DEFINED_IN -> SqlQuery.target_table). Often the more useful answer "
+        "to 'where do I change this table's logic?' than the DDL file alone.",
+    )
     noise_excluded: list[str] = Field(
         default_factory=list,
         description="Definition file paths that were flagged as backup/noise.",

sqlcg/server/tools.py

@@ -21,10 +21,14 @@ from sqlcg.core.queries import (
     FIND_TABLE_USAGES_QUERY,
     GET_COLUMNS_FOR_TABLE_QUERY,
     GET_DOWNSTREAM_DEPENDENCIES_QUERY,
+    GET_PRODUCER_FILES_FOR_TABLE_QUERY,
+    GET_TABLE_ADJACENCY_FOR_COLUMNS_QUERY,
     GET_TABLE_DEFINING_FILES_QUERY,
     GET_TABLE_DIRECT_UPSTREAMS_QUERY,
+    GET_TABLE_KINDS_BATCH_QUERY,
     GET_TABLES_DEFINED_IN_FILE_QUERY,
     GET_TABLES_EXTERNAL_CONSUMERS_BATCH_QUERY,
+    GET_TARGET_TABLES_FOR_FILE_QUERY,
     GET_UPSTREAM_DEPENDENCIES_QUERY,
     HUB_RANKING_QUERY,
     INDEX_REPO_FILES_QUERY,
@@ -396,6 +400,51 @@ def _rollup_to_tables(col_ids: list[str]) -> list[str]:
     return tables
 
 
+# Synthetic SqlTable.kind values that must never surface as rebuildable tables —
+# the authoritative marker per indexer.py (kind="cte" / kind="derived"); see
+# _exclude_synthetic_tables. Keying on kind (not the alias string) avoids dropping
+# a real table that happens to share a name with a CTE alias.
+_SYNTHETIC_TABLE_KINDS = frozenset({"cte", "derived"})
+
+
+def _exclude_synthetic_tables(db: GraphBackend, tables: list[str]) -> tuple[list[str], list[str]]:
+    """Split *tables* into (real, synthetic) using the authoritative SqlTable.kind.
+
+    Synthetic CTE/derived nodes (``kind in {"cte", "derived"}``) are emitted into
+    the graph for lineage-tracing purposes but must never surface as rebuildable
+    tables in get_change_scope / get_backfill_order / diff_impact / scope_change
+    (issue #38 synthetic-node leak). Exclusion is keyed on ``kind`` — the
+    authoritative marker set in indexer.py — never on the alias string, so a real
+    table that happens to share a name with a CTE alias is never dropped.
+
+    Args:
+        db: Graph backend.
+        tables: Candidate table_qualified strings (already noise-filtered).
+
+    Returns:
+        (real_tables, synthetic_excluded) — both order-preserving, deduplicated.
+    """
+    if not tables:
+        return [], []
+
+    rows = db.run_read(GET_TABLE_KINDS_BATCH_QUERY, {"table_qualifieds": tables})
+    synthetic_ids = {
+        row["table_qualified"] for row in rows if row["kind"] in _SYNTHETIC_TABLE_KINDS
+    }
+
+    if not synthetic_ids:
+        return tables, []
+
+    real: list[str] = []
+    synthetic: list[str] = []
+    for t in tables:
+        if t in synthetic_ids:
+            synthetic.append(t)
+        else:
+            real.append(t)
+    return real, synthetic
+
+
 def _dedup_preserve_order(items: list[str]) -> list[str]:
     """Deduplicate a list while preserving first-seen order."""
     out: list[str] = []
@@ -421,30 +470,84 @@ def _risk_label(affected_table_count: int) -> str:
     return "high"
 
 
-def _kahn_topological_sort(affected_tables: list[str], db: GraphBackend) -> tuple[list[str], bool]:
+def _kahn_topological_sort(
+    affected_tables: list[str], db: GraphBackend, closure_col_ids: list[str]
+) -> tuple[list[str], bool]:
     """Order affected tables so producers come before consumers (rebuild order).
 
-    Builds an adjacency list from SELECTS_FROM edges *within* the affected set
-    (a table's producing query selecting from another affected table is an edge
-    producer -> consumer) and runs Kahn's algorithm. Returns
-    (ordered_tables, had_cycle). On a cycle the acyclic prefix is emitted in
-    topological order and the remaining cyclic tables are appended in input
-    order — no exception is raised.
+    Builds adjacency from the **COLUMN_LINEAGE closure** (Option A — issue #38),
+    not from ``SELECTS_FROM``: CTE-wrapped ``INSERT ... WITH cte AS (...) SELECT
+    ... FROM cte`` statements emit no ``SELECTS_FROM`` adjacency at all (the real
+    source table is nested in the CTE's child scope and never surfaces into the
+    statement's top-level ``sources``), which previously left every table at
+    indegree 0 and degraded ordering to alphabetical.
+
+    ``COLUMN_LINEAGE`` *does* carry the producer -> consumer connectivity, but —
+    contrary to an earlier (unreproduced) assumption of a parallel direct edge —
+    it bridges producer and consumer via a **two-hop path through the synthetic
+    cte/derived node** (``producer -> cte -> consumer``), not a parallel direct
+    edge bypassing it. Rolling the raw closure up to table level therefore yields
+    edges *to and from* synthetic nodes, not real producer -> consumer adjacency
+    directly. This function **contracts** those synthetic-node hops in one pass
+    over the (small) rolled-up edge set — ``real -> synthetic -> ... -> real``
+    collapses to ``real -> real`` — yielding the true causal adjacency. Still
+    **one** aggregate query + one contraction pass per closure (never
+    per-table/per-column; replaces the old N x GET_TABLE_DIRECT_UPSTREAMS loop).
+
+    Runs Kahn's algorithm over the contracted adjacency. Returns (ordered_tables,
+    had_cycle). On a cycle the acyclic prefix is emitted in topological order
+    and the remaining cyclic tables are appended in input order — no exception
+    is raised.
+
+    Args:
+        affected_tables: Noise-filtered, synthetic-excluded table set to order.
+        db: Graph backend.
+        closure_col_ids: Full column-id set of the closure (start columns plus
+            their transitive downstream columns) — both endpoints of every
+            producer -> consumer hop (including synthetic bridges) must be
+            present here for the adjacency query to find the connecting path.
     """
     table_set = set(affected_tables)
     successors: dict[str, set[str]] = {t: set() for t in affected_tables}
     indegree: dict[str, int] = {t: 0 for t in affected_tables}
 
-    for table in affected_tables:
+    if closure_col_ids:
         rows = db.run_read(
-            GET_TABLE_DIRECT_UPSTREAMS_QUERY,
-            {"table_qualified": table, "table_qualified2": table},
+            GET_TABLE_ADJACENCY_FOR_COLUMNS_QUERY,
+            {"col_ids": closure_col_ids, "col_ids2": closure_col_ids},
         )
+        # Raw rolled-up adjacency, including synthetic (cte/derived) endpoints.
+        raw_successors: dict[str, set[str]] = {}
+        synthetic_nodes: set[str] = set()
         for row in rows:
-            src = row["upstream_table"]
-            if src in table_set and src != table and table not in successors[src]:
-                successors[src].add(table)
-                indegree[table] += 1
+            src, dst = row["upstream_table"], row["downstream_table"]
+            if src == dst:
+                continue
+            raw_successors.setdefault(src, set()).add(dst)
+            if row["upstream_kind"] in _SYNTHETIC_TABLE_KINDS:
+                synthetic_nodes.add(src)
+            if row["downstream_kind"] in _SYNTHETIC_TABLE_KINDS:
+                synthetic_nodes.add(dst)
+
+        # Contract synthetic-node hops: from each real producer, BFS through
+        # any chain of synthetic nodes to find the real consumers it reaches —
+        # `real -> synthetic [-> synthetic ...] -> real` collapses to `real -> real`.
+        for src in table_set:
+            seen_chain: set[str] = set()
+            frontier = deque(raw_successors.get(src, ()))
+            while frontier:
+                node = frontier.popleft()
+                if node in seen_chain:
+                    continue
+                seen_chain.add(node)
+                if node in table_set:
+                    if node != src and node not in successors[src]:
+                        successors[src].add(node)
+                        indegree[node] += 1
+                elif node in synthetic_nodes:
+                    frontier.extend(raw_successors.get(node, ()))
+                # Real nodes outside table_set (e.g. noise-filtered) are dead ends —
+                # do not traverse through them; only synthetic bridges are contracted.
 
     # Sort the zero-indegree frontier for deterministic output.
     ready: deque[str] = deque(sorted(t for t in affected_tables if indegree[t] == 0))
@@ -842,7 +945,10 @@ def find_definition(table_qualified: str) -> DefinitionResult:
     with _open_backend() as db:
         _assert_indexed(db)
 
-        rows = db.run_read(FIND_DEFINITION_QUERY, {"table_qualified": table_qualified.lower()})
+        target = table_qualified.lower()
+        rows = db.run_read(FIND_DEFINITION_QUERY, {"table_qualified": target})
+        producer_rows = db.run_read(GET_PRODUCER_FILES_FOR_TABLE_QUERY, {"table_qualified": target})
+        producer_files = _dedup_preserve_order([r["file_path"] for r in producer_rows])
         noise_filter = NoiseFilter.from_config()
 
         duplicate_ddl = len(rows) > 1
@@ -874,6 +980,7 @@ def find_definition(table_qualified: str) -> DefinitionResult:
             table_qualified=table_qualified,
             definitions=definitions,
             duplicate_ddl=duplicate_ddl,
+            producer_files=producer_files,
             noise_excluded=noise_excluded,
             hint=hint,
         )
@@ -905,7 +1012,10 @@ def get_change_scope(table_qualified: str) -> ChangeScopeResult:
         noise_filter = NoiseFilter.from_config()
 
         def_rows = db.run_read(GET_TABLE_DEFINING_FILES_QUERY, {"table_qualified": target})
-        defining_files = _dedup_preserve_order([r["file_path"] for r in def_rows])
+        producer_rows = db.run_read(GET_PRODUCER_FILES_FOR_TABLE_QUERY, {"table_qualified": target})
+        defining_files = _dedup_preserve_order(
+            [r["file_path"] for r in def_rows] + [r["file_path"] for r in producer_rows]
+        )
 
         up_rows = db.run_read(
             GET_TABLE_DIRECT_UPSTREAMS_QUERY,
@@ -921,7 +1031,13 @@ def get_change_scope(table_qualified: str) -> ChangeScopeResult:
         affected_cols, _depth, truncated = _affected_columns_closure(db, start_cols, max_depth=None)
 
         affected_tables_all = [t for t in _rollup_to_tables(affected_cols) if t != target]
-        affected_tables, noise_excluded = noise_filter.filter_nodes(affected_tables_all)
+        affected_tables_noise_filtered, noise_excluded = noise_filter.filter_nodes(
+            affected_tables_all
+        )
+        affected_tables, synthetic_excluded = _exclude_synthetic_tables(
+            db, affected_tables_noise_filtered
+        )
+        noise_excluded = [*noise_excluded, *synthetic_excluded]
         kept_tables = set(affected_tables)
         affected_columns = [c for c in affected_cols if c.rsplit(".", 1)[0] in kept_tables]
 
@@ -985,11 +1101,21 @@ def get_backfill_order(table_qualified: str) -> BackfillOrderResult:
         affected_cols, _depth, truncated = _affected_columns_closure(db, start_cols, max_depth=None)
 
         affected_tables_all = [t for t in _rollup_to_tables(affected_cols) if t != target]
-        affected_tables, noise_excluded = noise_filter.filter_nodes(affected_tables_all)
+        affected_tables_noise_filtered, noise_excluded = noise_filter.filter_nodes(
+            affected_tables_all
+        )
+        affected_tables, synthetic_excluded = _exclude_synthetic_tables(
+            db, affected_tables_noise_filtered
+        )
+        noise_excluded = [*noise_excluded, *synthetic_excluded]
         kept_tables = set(affected_tables)
         affected_columns = [c for c in affected_cols if c.rsplit(".", 1)[0] in kept_tables]
 
-        order, had_cycle = _kahn_topological_sort(affected_tables, db)
+        # Option A (issue #38): adjacency is derived from the same COLUMN_LINEAGE
+        # closure as membership — pass the full id set (start + affected) so the
+        # direct producer->consumer edge endpoints are both present.
+        closure_col_ids = _dedup_preserve_order([*start_cols, *affected_cols])
+        order, had_cycle = _kahn_topological_sort(affected_tables, db, closure_col_ids)
 
         hint = None
         if had_cycle:
@@ -1044,19 +1170,26 @@ def diff_impact(changed_files: list[str]) -> DiffImpactResult:
             fp = Path(file_path)
             if not fp.is_absolute():
                 fp = root / fp
-            rows = db.run_read(GET_TABLES_DEFINED_IN_FILE_QUERY, {"file_path": str(fp)})
-            for row in rows:
-                tq = row["table_qualified"]
-                if tq not in seen_changed:
-                    seen_changed.add(tq)
-                    changed_tables.append(tq)
+            for query in (GET_TABLES_DEFINED_IN_FILE_QUERY, GET_TARGET_TABLES_FOR_FILE_QUERY):
+                rows = db.run_read(query, {"file_path": str(fp)})
+                for row in rows:
+                    tq = row["table_qualified"]
+                    if tq and tq not in seen_changed:
+                        seen_changed.add(tq)
+                        changed_tables.append(tq)
 
         all_affected_cols: list[str] = []
         affected_seen: set[str] = set()
+        all_start_cols: list[str] = []
+        start_seen: set[str] = set()
         truncated = False
         for tq in changed_tables:
             col_rows = db.run_read(GET_COLUMNS_FOR_TABLE_QUERY, {"table_qualified": tq})
             start_cols = [r["col_id"] for r in col_rows]
+            for col in start_cols:
+                if col not in start_seen:
+                    start_seen.add(col)
+                    all_start_cols.append(col)
             cols, _depth, tr = _affected_columns_closure(db, start_cols, max_depth=None)
             truncated = truncated or tr
             for col in cols:
@@ -1067,9 +1200,18 @@ def diff_impact(changed_files: list[str]) -> DiffImpactResult:
         affected_tables_all = [
             t for t in _rollup_to_tables(all_affected_cols) if t not in seen_changed
         ]
-        affected_tables, noise_excluded = noise_filter.filter_nodes(affected_tables_all)
+        affected_tables_noise_filtered, noise_excluded = noise_filter.filter_nodes(
+            affected_tables_all
+        )
+        affected_tables, synthetic_excluded = _exclude_synthetic_tables(
+            db, affected_tables_noise_filtered
+        )
+        noise_excluded = [*noise_excluded, *synthetic_excluded]
         presentation_facing = [t for t in affected_tables if any(t.startswith(p) for p in prefixes)]
-        order, had_cycle = _kahn_topological_sort(affected_tables, db)
+        # Option A (issue #38): same closure-derived adjacency as get_backfill_order —
+        # union of every changed table's start columns plus the unioned affected set.
+        closure_col_ids = _dedup_preserve_order([*all_start_cols, *all_affected_cols])
+        order, had_cycle = _kahn_topological_sort(affected_tables, db, closure_col_ids)
 
         # Resolve external consumers for the blast radius in a single BATCH query (not per-table).
         external_consumers: list[str] = []