sql-code-graph 1.33.0__tar.gz → 1.34.0__tar.gz

{sql_code_graph-1.33.0 → sql_code_graph-1.34.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-code-graph
-Version: 1.33.0
+Version: 1.34.0
 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.34.0/plan/metrics/lineage5_dwh_after_pr5.json

@@ -0,0 +1,9 @@
+{
+  "elapsed_sec": 184.3,
+  "files_parsed": 1335,
+  "join_cols_resolved_summary": 1142,
+  "join_col_resolve_markers": 1039,
+  "join_col_resolved_edges": 1142,
+  "rescuable_unqualified_edges": 125,
+  "resolvable_write_col_edges": 35759
+}

sql_code_graph-1.34.0/plan/metrics/lineage5_dwh_before_master.json

@@ -0,0 +1,6 @@
+{
+  "elapsed_sec": 165.8,
+  "files_parsed": 1335,
+  "rescuable_unqualified_edges": 131,
+  "resolvable_write_col_edges": 35660
+}

{sql_code_graph-1.33.0 → sql_code_graph-1.34.0}/pyproject.toml

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

{sql_code_graph-1.33.0 → sql_code_graph-1.34.0}/src/sqlcg/__init__.py

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

{sql_code_graph-1.33.0 → sql_code_graph-1.34.0}/src/sqlcg/core/duckdb_backend.py

@@ -203,6 +203,14 @@ _EDGE_DDLS = [
         PRIMARY KEY (src_key, dst_key)
     )
     """,
+    """
+    CREATE TABLE IF NOT EXISTS "JOIN_COL_RESOLVE" (
+        src_key VARCHAR NOT NULL,
+        dst_key VARCHAR NOT NULL,
+        bare_col VARCHAR,
+        PRIMARY KEY (src_key, dst_key)
+    )
+    """,
 ]
 
 _INDEX_DDLS = [
@@ -230,6 +238,8 @@ _INDEX_DDLS = [
     'CREATE INDEX IF NOT EXISTS idx_STAR_SOURCE_dst ON "STAR_SOURCE" (dst_key)',
     'CREATE INDEX IF NOT EXISTS idx_CONSUMED_BY_src ON "CONSUMED_BY" (src_key)',
     'CREATE INDEX IF NOT EXISTS idx_CONSUMED_BY_dst ON "CONSUMED_BY" (dst_key)',
+    'CREATE INDEX IF NOT EXISTS idx_JOIN_COL_RESOLVE_src ON "JOIN_COL_RESOLVE" (src_key)',
+    'CREATE INDEX IF NOT EXISTS idx_JOIN_COL_RESOLVE_dst ON "JOIN_COL_RESOLVE" (dst_key)',
 ]
 
 # Node label → column list (all columns of that table, in order)
@@ -304,6 +314,7 @@ _EDGE_EXTRA_COLUMNS: dict[str, list[str]] = {
     RelType.DECLARES: [],
     RelType.STAR_SOURCE: ["qualifier", "target_table", "confidence"],
     RelType.CONSUMED_BY: [],
+    RelType.JOIN_COL_RESOLVE: ["bare_col"],
 }
 
 
@@ -752,6 +763,7 @@ class DuckDBBackend(GraphBackend):
                     "UPDATES",
                     "DECLARES",
                     "STAR_SOURCE",
+                    "JOIN_COL_RESOLVE",
                 ):
                     self._conn.execute(
                         f'DELETE FROM "{edge_table}" WHERE src_key IN ({placeholders})',
@@ -891,6 +903,39 @@ class DuckDBBackend(GraphBackend):
         row = result.fetchone()
         return int(row[0]) if row else 0
 
+    def resolve_join_columns(self) -> int:
+        """Resolve JOIN_COL_RESOLVE markers into concrete COLUMN_LINEAGE edges.
+
+        Runs AFTER ingestion AND after the catalog has been applied, so that
+        information_schema ``HAS_COLUMN`` rows are present.  For each parse-time
+        marker (a bare unqualified column in a >=2-table join projection), it
+        finds which of the query's source tables owns a column with that bare
+        name (any HAS_COLUMN source), normalising casing on both sides:
+
+          - exactly one owner  -> one high-confidence (0.9) edge (the dominant
+            live case: the second table is visible only via information_schema);
+          - more than one owner -> one low-confidence (0.5) edge per owner
+            (genuine ambiguity; over-attribute, never silently mis-pick);
+          - zero owners         -> emit nothing (honest empty; XML-DDL gap).
+
+        Mirrors :meth:`expand_star_sources` (post-index SQL pass).  The
+        suppressed sqlglot mis-bind edge is never emitted at parse time, so this
+        pass is the SOLE producer of these columns' edges — it MUST run in every
+        path that re-creates the markers (full index + both incremental paths).
+
+        Returns:
+            Number of COLUMN_LINEAGE JOIN_COL_RESOLVED edges present afterward.
+        """
+        from sqlcg.core.queries import RESOLVE_JOIN_COLUMNS_QUERY
+
+        self._conn.execute(RESOLVE_JOIN_COLUMNS_QUERY)
+        result = self._conn.execute(
+            'SELECT count(*) AS n FROM "COLUMN_LINEAGE" WHERE transform = ?',
+            ["JOIN_COL_RESOLVED"],
+        )
+        row = result.fetchone()
+        return int(row[0]) if row else 0
+
     # ------------------------------------------------------------------
     # Full-rebuild helpers
     # ------------------------------------------------------------------
@@ -927,6 +972,7 @@ class DuckDBBackend(GraphBackend):
             "DECLARES",
             "STAR_SOURCE",
             "CONSUMED_BY",
+            "JOIN_COL_RESOLVE",
         ]
         for tbl in edge_tables + node_tables:
             self._conn.execute(f'DELETE FROM "{tbl}"')

{sql_code_graph-1.33.0 → sql_code_graph-1.34.0}/src/sqlcg/core/graph_db.py

@@ -273,6 +273,16 @@ class GraphBackend(ABC):
         """
         raise NotImplementedError(f"{type(self).__name__} does not support expand_star_sources")
 
+    def resolve_join_columns(self) -> int:
+        """Resolve JOIN_COL_RESOLVE markers into per-column COLUMN_LINEAGE edges.
+
+        Runs once per index after ingestion AND catalog apply, resolving bare
+        unqualified join columns against the full post-index HAS_COLUMN catalog
+        (including information_schema rows unavailable at parse time). Concrete
+        backends must override this; returns the total JOIN_COL_RESOLVED edge count.
+        """
+        raise NotImplementedError(f"{type(self).__name__} does not support resolve_join_columns")
+
 
 def indexed_repo_root(db: "GraphBackend") -> Path | None:
     """Return the indexed root path stored on the first Repo node, or None.

{sql_code_graph-1.33.0 → sql_code_graph-1.34.0}/src/sqlcg/core/queries.py

@@ -51,6 +51,8 @@ LIST_DIALECTS_AND_REPOS_QUERY = _Q["LIST_DIALECTS_AND_REPOS"]
 EXPAND_STAR_SOURCES_QUERY = _Q["EXPAND_STAR_SOURCES"]
 EXPAND_STAR_SOURCES_HAS_COLUMN_QUERY = _Q["EXPAND_STAR_SOURCES_HAS_COLUMN"]
 EXPAND_STAR_SOURCES_LINEAGE_QUERY = _Q["EXPAND_STAR_SOURCES_LINEAGE"]
+RESOLVE_JOIN_COLUMNS_QUERY = _Q["RESOLVE_JOIN_COLUMNS"]
+COUNT_JOIN_COL_RESOLVED_QUERY = _Q["COUNT_JOIN_COL_RESOLVED"]
 COUNT_STAR_SOURCES_QUERY = _Q["COUNT_STAR_SOURCES"]
 COUNT_STAR_EXPANSIONS_QUERY = _Q["COUNT_STAR_EXPANSIONS"]
 FIND_DEFINITION_QUERY = _Q["FIND_DEFINITION"]

{sql_code_graph-1.33.0 → sql_code_graph-1.34.0}/src/sqlcg/core/queries.sql

@@ -148,6 +148,53 @@ JOIN "SqlTable" tgt ON tgt.qualified = q.target_table
 WHERE q.target_table <> ''
   AND q.target_table <> t.qualified
 
+-- RESOLVE_JOIN_COLUMNS
+-- Resolve JOIN_COL_RESOLVE markers (bare unqualified join columns whose owning
+-- table was only knowable post-index, e.g. catalogued via information_schema)
+-- into concrete COLUMN_LINEAGE edges.
+--
+-- For each marker (src_key=query_id, dst_key=<dst_table>.<dst_col>, bare_col):
+--   find which of the query's SELECTS_FROM source tables OWNS a column named
+--   bare_col (any HAS_COLUMN source: ddl | information_schema | star_expansion |
+--   usage).  Casing is normalised on BOTH sides of the owner-match join because
+--   information_schema stores col_name as exported (e.g. STATUS) while the parsed
+--   bare name is lowercased (status).
+--
+-- Confidence contract:
+--   - exactly one owning table  -> HIGH confidence (0.9), the resolved edge
+--   - more than one owning table -> one LOW confidence (0.5) edge per owner
+--     (genuine ambiguity: over-attribute, never silently mis-pick)
+--   - zero owning tables         -> emit nothing (honest empty; XML-DDL gap)
+-- A window COUNT over the owning tables per marker selects the confidence in one
+-- pass.
+-- params: []
+INSERT OR REPLACE INTO "COLUMN_LINEAGE"
+  (src_key, dst_key, transform, confidence, query_id, inferred_from_source_name)
+SELECT
+  src_key,
+  dst_key,
+  'JOIN_COL_RESOLVED' AS transform,
+  CASE WHEN n_owners = 1 THEN 0.9 ELSE 0.5 END AS confidence,
+  query_id,
+  FALSE AS inferred_from_source_name
+FROM (
+  SELECT
+    c.id AS src_key,
+    m.dst_key AS dst_key,
+    m.src_key AS query_id,
+    count(*) OVER (PARTITION BY m.src_key, m.dst_key) AS n_owners
+  FROM "JOIN_COL_RESOLVE" m
+  JOIN "SELECTS_FROM" sf ON sf.src_key = m.src_key
+  JOIN "HAS_COLUMN" hc ON hc.src_key = sf.dst_key
+  JOIN "SqlColumn" c
+    ON c.id = hc.dst_key
+   AND lower(c.col_name) = lower(m.bare_col)
+) owners
+
+-- COUNT_JOIN_COL_RESOLVED
+-- params: []
+SELECT count(*) AS n FROM "COLUMN_LINEAGE" WHERE transform = 'JOIN_COL_RESOLVED'
+
 -- COUNT_STAR_SOURCES
 -- params: []
 SELECT count(*) AS n FROM "STAR_SOURCE"

{sql_code_graph-1.33.0 → sql_code_graph-1.34.0}/src/sqlcg/core/schema.py

@@ -3,7 +3,7 @@
 from enum import StrEnum
 from importlib.resources import files
 
-SCHEMA_VERSION = "10"
+SCHEMA_VERSION = "11"
 
 
 class NodeLabel(StrEnum):
@@ -29,6 +29,7 @@ class RelType(StrEnum):
     DECLARES = "DECLARES"
     STAR_SOURCE = "STAR_SOURCE"
     CONSUMED_BY = "CONSUMED_BY"
+    JOIN_COL_RESOLVE = "JOIN_COL_RESOLVE"
 
 
 # Backward-compatible aliases

{sql_code_graph-1.33.0 → sql_code_graph-1.34.0}/src/sqlcg/indexer/indexer.py

@@ -47,6 +47,7 @@ class FileRowSet:
     selects_from_edges: list[dict] = field(default_factory=list)
     column_lineage_edges: list[dict] = field(default_factory=list)
     star_source_edges: list[dict] = field(default_factory=list)
+    join_col_resolve_edges: list[dict] = field(default_factory=list)
     counts: dict = field(
         default_factory=lambda: {"tables": 0, "edges": 0, "columns_defined": 0, "star_sources": 0}
     )
@@ -71,6 +72,7 @@ class BatchRowBuffer:
     selects_from_edges: list[dict] = field(default_factory=list)
     column_lineage_edges: list[dict] = field(default_factory=list)
     star_source_edges: list[dict] = field(default_factory=list)
+    join_col_resolve_edges: list[dict] = field(default_factory=list)
 
     def extend(self, rows: FileRowSet) -> None:
         """Accumulate one file's row sets into this buffer."""
@@ -84,6 +86,7 @@ class BatchRowBuffer:
         self.selects_from_edges.extend(rows.selects_from_edges)
         self.column_lineage_edges.extend(rows.column_lineage_edges)
         self.star_source_edges.extend(rows.star_source_edges)
+        self.join_col_resolve_edges.extend(rows.join_col_resolve_edges)
 
     @classmethod
     def from_single(cls, rows: FileRowSet) -> "BatchRowBuffer":
@@ -292,6 +295,9 @@ def _flush_row_batch(
     star_source_edges = list(
         {(r["src_key"], r["dst_key"]): r for r in buf.star_source_edges}.values()
     )
+    join_col_resolve_edges = list(
+        {(r["src_key"], r["dst_key"]): r for r in buf.join_col_resolve_edges}.values()
+    )
 
     # --- Phase B2: usage-derived catalog harvest ---
     # Post-dedup: for each COLUMN_LINEAGE src endpoint whose table is a physical
@@ -345,6 +351,11 @@ def _flush_row_batch(
             star_source_edges = [
                 r for r in star_source_edges if r["dst_key"] not in excluded_tables
             ]
+            join_col_resolve_edges = [
+                r
+                for r in join_col_resolve_edges
+                if _table_of_column_id(r["dst_key"]) not in excluded_tables
+            ]
             column_lineage_edges = [
                 r
                 for r in column_lineage_edges
@@ -372,6 +383,9 @@ def _flush_row_batch(
         NodeLabel.COLUMN, NodeLabel.COLUMN, RelType.COLUMN_LINEAGE, column_lineage_edges
     )
     db.upsert_edges_bulk(NodeLabel.QUERY, NodeLabel.TABLE, RelType.STAR_SOURCE, star_source_edges)
+    db.upsert_edges_bulk(
+        NodeLabel.QUERY, NodeLabel.COLUMN, RelType.JOIN_COL_RESOLVE, join_col_resolve_edges
+    )
 
 
 def _subprocess_parse_worker(parser_cls, dialect, path, sql, q):
@@ -882,6 +896,12 @@ class Indexer:
         if profile:
             _t_catalog_end = time.perf_counter()
 
+        # Post-catalog: resolve JOIN_COL_RESOLVE markers against the full HAS_COLUMN
+        # catalog (Bug #5, PR-5 option b). MUST run after the catalog is applied so
+        # information_schema columns are present; the suppressed sqlglot mis-bind
+        # edge is never emitted, so this is the sole producer of the resolved edges.
+        join_cols_resolved = self._resolve_join_columns(db)
+
         # Classify all errors into buckets for measurement and reporting
         error_summary: dict[str, int] = {
             "E1": 0,
@@ -931,6 +951,7 @@ class Indexer:
             "columns_defined": nonlocal_counts["columns_defined"],
             "star_sources": nonlocal_counts["star_sources"],
             "star_edges_expanded": star_edges_expanded,
+            "join_cols_resolved": join_cols_resolved,
             "quality": nonlocal_counts["quality"],
             "error_summary": error_summary,
             "degraded_files": degraded_files,
@@ -1329,6 +1350,14 @@ class Indexer:
         # ---- Step 8: Single star expansion (same as index_repo) ------------------
         self._expand_star_sources(db)
 
+        # ---- Step 8b: Resolve JOIN_COL_RESOLVE markers (Bug #5, PR-5 option b) ----
+        # The incremental path does NOT reapply the catalog — it resolves against the
+        # information_schema HAS_COLUMN rows persisted by the prior full index. Without
+        # this, a delta touching a join file would re-create the markers but never
+        # resolve them, silently dropping the join-column edges until the next full
+        # index (plan-review BLOCKER).
+        self._resolve_join_columns(db)
+
         # ---- Step 9: Persist new SHA on success ----------------------------------
         db.set_indexed_sha(new_sha)
 
@@ -1382,6 +1411,13 @@ class Indexer:
         # Re-run star expansion after re-indexing
         self._expand_star_sources(db)
 
+        # Resolve JOIN_COL_RESOLVE markers (Bug #5, PR-5 option b) against the
+        # information_schema HAS_COLUMN rows persisted by the prior full index. The
+        # single-file path does NOT reapply the catalog; without re-resolving here a
+        # reindex of a join file would re-create the markers but drop the resolved
+        # join-column edges until the next full index (plan-review BLOCKER).
+        self._resolve_join_columns(db)
+
     def _index_single_file(self, parser, path: Path, sql: str, timeout: int) -> ParsedFile:
         """Parse one file, with optional timeout via subprocess isolation.
 
@@ -1706,6 +1742,21 @@ class Indexer:
                 )
                 rows.counts["star_sources"] += 1
 
+            # JOIN_COL_RESOLVE markers (Bug #5, PR-5 option b): bare unqualified
+            # join-projection columns whose owning source table is only knowable
+            # post-index (e.g. catalogued via information_schema). The sqlglot
+            # mis-bind edge was suppressed at parse time; the post-index resolver
+            # (DuckDBBackend.resolve_join_columns) is the SOLE producer of these
+            # columns' COLUMN_LINEAGE edges. src_key=query_id, dst_key=<dst>.<col>.
+            for jcr in stmt.join_col_resolves:
+                rows.join_col_resolve_edges.append(
+                    {
+                        "src_key": query_id,
+                        "dst_key": jcr.dst.full_id,
+                        "bare_col": jcr.bare_col,
+                    }
+                )
+
             # Upsert target table node (if not already a defined_table)
             # so that star expansion can create destination columns.
             # #44: when a canonical_by_bare index is available, attempt to resolve
@@ -1930,6 +1981,22 @@ class Indexer:
         """
         return db.expand_star_sources()
 
+    def _resolve_join_columns(self, db: GraphBackend) -> int:
+        """Run the post-index join-column resolution (Bug #5, PR-5 option b).
+
+        Calls DuckDBBackend.resolve_join_columns(), which resolves JOIN_COL_RESOLVE
+        markers (bare unqualified join columns) against the full post-index
+        HAS_COLUMN catalog — including information_schema rows unavailable at parse
+        time. MUST run AFTER the catalog is applied (full-index path) and AFTER star
+        expansion in every path that re-creates the markers; the suppressed sqlglot
+        mis-bind edge is never emitted, so this pass is the SOLE producer of these
+        columns' edges.
+
+        Returns:
+            Number of COLUMN_LINEAGE JOIN_COL_RESOLVED edges after resolution.
+        """
+        return db.resolve_join_columns()
+
     def _ingest_external_consumers(self, db: GraphBackend, path: Path) -> dict:
         """Ingest declared external downstream consumers from .sqlcg.toml.
 

{sql_code_graph-1.33.0 → sql_code_graph-1.34.0}/src/sqlcg/parsers/ansi_parser.py

@@ -622,6 +622,7 @@ class AnsiParser(SqlParser):
             )
         column_lineage = extraction.edges
         star_sources = extraction.star_sources
+        join_col_resolves = extraction.join_col_resolves
         stmt_qualify_failed = extraction.qualify_failed
 
         # Extract defined columns for CREATE TABLE statements
@@ -666,6 +667,7 @@ class AnsiParser(SqlParser):
             parsing_mode="sqlglot",
             defined_columns=defined_columns,
             star_sources=star_sources,
+            join_col_resolves=join_col_resolves,
             defined_body=defined_body,
             clone_source=clone_source,
         )

{sql_code_graph-1.33.0 → sql_code_graph-1.34.0}/src/sqlcg/parsers/base.py

@@ -204,6 +204,32 @@ class StarSource:
     qualifier: str | None = None
 
 
+@dataclass(frozen=True)
+class JoinColResolve:
+    """A deferred-resolution marker for a bare unqualified join-projection column.
+
+    Emitted (instead of the sqlglot mis-bind edge) when a top-level INSERT/CREATE
+    SELECT projection contains a bare column (``exp.Column`` with no ``.table``)
+    AND the statement has >=2 source tables.  The owning source table is only
+    knowable AFTER indexing (e.g. catalogued via information_schema), so the
+    binding is deferred to ``DuckDBBackend.resolve_join_columns`` — the post-index
+    pass is the SOLE producer of the resolved COLUMN_LINEAGE edge for this column.
+
+    Mirrors the over-attribution-instead-of-mis-bind discipline of the
+    ``CTE_PROJECTION_AMBIGUOUS`` precedent (see PR-5 in
+    plan/sprints/bugfix_lineage_correctness_validation.md).
+
+    Attributes:
+        dst: The destination ColumnRef the projection would have produced
+            (``<dst_table>.<dst_col_name>``); its full_id is the marker's dst_key.
+        bare_col: The bare (unqualified) column name to resolve against source
+            tables' HAS_COLUMN catalog.
+    """
+
+    dst: ColumnRef
+    bare_col: str = ""
+
+
 @dataclass(frozen=True)
 class LineageExtraction:
     """Result of column lineage extraction, including both edges and star markers.
@@ -211,6 +237,8 @@ class LineageExtraction:
     Attributes:
         edges: List of LineageEdge objects extracted from the statement
         star_sources: List of StarSource markers for SELECT * projections
+        join_col_resolves: List of JoinColResolve markers for bare unqualified
+            >=2-table join projections, resolved post-index against HAS_COLUMN.
         qualify_failed: True when the qualify() step raised an exception for
             this statement (schema-free retry may still yield a partial scope).
             Propagated to QueryNode.qualify_failed for per-statement storage.
@@ -218,6 +246,7 @@ class LineageExtraction:
 
     edges: list[LineageEdge]
     star_sources: list[StarSource]
+    join_col_resolves: list[JoinColResolve] = field(default_factory=list)
     qualify_failed: bool = False
 
 
@@ -268,6 +297,7 @@ class QueryNode:
     confidence: float = 1.0
     parsing_mode: str = "sqlglot"
     star_sources: list[StarSource] = field(default_factory=list)
+    join_col_resolves: list[JoinColResolve] = field(default_factory=list)
     defined_columns: list[str] = field(default_factory=list)
     defined_body: Any | None = None
     start_line: int = 0  # 1-based start line of statement in file; 0 = unknown
@@ -413,6 +443,22 @@ def normalize_keys(parsed: "ParsedFile", aliases: dict[str, str]) -> None:
         if stmt.clone_source is not None:
             stmt.clone_source = _norm_ref(stmt.clone_source)
 
+        # join_col_resolves (JoinColResolve.dst is a ColumnRef over a TableRef).
+        # The dst table is the INSERT/CREATE target, which is aliased above; keep
+        # the marker's dst_key in lockstep so the post-index resolver writes a
+        # COLUMN_LINEAGE edge with the same dst key as the rest of the graph.
+        new_join_col_resolves: list[JoinColResolve] = []
+        for jcr in stmt.join_col_resolves:
+            new_dst_table = _norm_ref(jcr.dst.table)
+            if new_dst_table is None:
+                # Empty-identity target — drop the marker (skip already logged).
+                continue
+            if new_dst_table is not jcr.dst.table:
+                new_dst = dataclasses.replace(jcr.dst, table=new_dst_table)
+                jcr = dataclasses.replace(jcr, dst=new_dst)
+            new_join_col_resolves.append(jcr)
+        stmt.join_col_resolves = new_join_col_resolves
+
         # column_lineage — LineageEdge and ColumnRef are frozen; rewrite via replace
         new_edges: list[LineageEdge] = []
         for edge in stmt.column_lineage:
@@ -1067,6 +1113,7 @@ class SqlParser(ABC):
 
         edges: list[LineageEdge] = []
         star_sources: list[StarSource] = []
+        join_col_resolves: list[JoinColResolve] = []
         _qualify_failed: bool = False
 
         # NEW (T-07-06): Record MERGE statements explicitly as deferred.
@@ -1417,6 +1464,23 @@ class SqlParser(ABC):
                         except Exception:
                             pass
 
+            # Bug #5 (PR-5, option b): count distinct PHYSICAL source tables ONCE per
+            # statement (never per column — CLAUDE.md hot-loop invariant). When a
+            # top-level INSERT/CREATE-SELECT join has >=2 physical sources, bare
+            # unqualified projection columns cannot be reliably bound at parse time
+            # (the owning table may be catalogued only via information_schema, which
+            # is unavailable to qualify()). For those columns we SUPPRESS the sqlglot
+            # mis-bind edge and record a JoinColResolve marker instead — resolved
+            # post-index against the full HAS_COLUMN catalog by
+            # DuckDBBackend.resolve_join_columns(). This mirrors the
+            # CTE_PROJECTION_AMBIGUOUS over-attribution discipline above, but defers
+            # resolution rather than over-attributing immediately. No new
+            # qualify/build_scope/exp.expand/sg_lineage call is added.
+            _physical_source_count = sum(
+                1 for _s in (query_sources or []) if getattr(_s, "role", "table") == "table"
+            )
+            _join_resolve_active = dst_table is not None and _physical_source_count >= 2
+
             # Extract output columns — skip positions handled by the positional INSERT block
             for loop_idx, col_expr in enumerate(col_expressions):
                 if loop_idx in positional_col_names:
@@ -1490,6 +1554,26 @@ class SqlParser(ABC):
                     expr_type = type(col_expr).__name__
                     out.errors.append(f"col_lineage_skip:func_fallback:{expr_type}")
                     continue
+
+                # Bug #5 (PR-5, option b): bare unqualified column in a >=2-physical-
+                # table join. SUPPRESS the sqlglot mis-bind edge (continue past
+                # sg_lineage) and record a JoinColResolve marker; the post-index
+                # resolver is the SOLE producer of this column's edge(s). A qualified
+                # reference (o.amount) has c.table set and fails the bare test, so it
+                # takes the existing sg_lineage path unchanged. This is the same
+                # cardinality as the existing edge append — no new hot-loop op.
+                if _join_resolve_active and dst_table is not None:
+                    _bare_cols = [c for c in col_expr.find_all(exp.Column) if not c.table]
+                    if _bare_cols:
+                        _bare_name = _bare_cols[0].name or col_name
+                        join_col_resolves.append(
+                            JoinColResolve(
+                                dst=ColumnRef(dst_table, col_name),
+                                bare_col=_bare_name,
+                            )
+                        )
+                        continue  # skip sg_lineage for this projection
+
                 # Schema validation: if schema is loaded and column isn't in it,
                 # emit a reduced-confidence edge rather than a full-confidence one.
                 # Skip when the expression has an explicit alias — the alias is the
@@ -1789,7 +1873,10 @@ class SqlParser(ABC):
             out.errors.append(f"col_lineage:statement:{exc}")
 
         return LineageExtraction(
-            edges=edges, star_sources=star_sources, qualify_failed=_qualify_failed
+            edges=edges,
+            star_sources=star_sources,
+            join_col_resolves=join_col_resolves,
+            qualify_failed=_qualify_failed,
         )
 
     def _resolve_star_source(

{sql_code_graph-1.33.0 → sql_code_graph-1.34.0}/src/sqlcg/server/tools.py

@@ -2532,12 +2532,16 @@ def _diff_lost_producers(
     lost_raw = before - after
     new_raw = after - before
 
-    # Exclude synthetic from both sides.
-    if lost_raw:
-        lost_cleaned, _ = _exclude_synthetic_tables(db, sorted(lost_raw))
-        lost_set = set(lost_cleaned)
-    else:
-        lost_set = set()
+    # Lost-producer side: do NOT apply _exclude_synthetic_tables.
+    # The lost set comes exclusively from GET_PRODUCER_TABLES (SqlQuery.target_table),
+    # which is only ever a real top-level write target — a CTE/derived intermediate alias
+    # is never a SqlQuery.target_table.  An INSERT target with no surviving consumers
+    # keeps kind='derived' (the indexer only upgrades 'derived'→'table' when a SELECT
+    # reads the table elsewhere), so applying _exclude_synthetic_tables here would drop
+    # genuine write targets that happen to be unconsumed (bug #3 false-safety signal).
+    # The synthetic filter is still applied to the NEW-producer side below (for rename
+    # classification), where genuine intermediate nodes can appear via new CTEs/views.
+    lost_set = set(lost_raw)
 
     if new_raw:
         new_cleaned, _ = _exclude_synthetic_tables(db, sorted(new_raw))

{sql_code_graph-1.33.0 → sql_code_graph-1.34.0}/tests/integration/test_T35_external_consumers.py

@@ -129,8 +129,8 @@ def test_schema_version_matches_current_migration():
     """
     from sqlcg.core.schema import SCHEMA_VERSION
 
-    assert SCHEMA_VERSION == "10", (
-        f"SCHEMA_VERSION must be '10' after the SchemaVersion.sqlcg_version column addition; "
+    assert SCHEMA_VERSION == "11", (
+        f"SCHEMA_VERSION must be '11' after the JOIN_COL_RESOLVE edge-table addition; "
         f"currently {SCHEMA_VERSION!r}"
     )