sql-code-graph 1.35.1__tar.gz → 1.35.2__tar.gz

{sql_code_graph-1.35.1 → sql_code_graph-1.35.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-code-graph
-Version: 1.35.1
+Version: 1.35.2
 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.35.2/plan/metrics/pr_c_merge_after.json

@@ -0,0 +1,31 @@
+{"total_calls": 1616, "last_7d_calls": 1616, "index_runs": 5, "feedback_tp": 0, 
+"feedback_total": 0, "top_tools": [{"name": "execute_sql", "count": 544}, 
+{"name": "trace_column_lineage", "count": 425}, {"name": 
+"list_dialects_and_repos", "count": 139}], "execute_sql_ratio": 0.34, 
+"parse_quality": {"sqlglot": 5166, "scripting": 20, "dynamic_sql": 3}, 
+"coverage": {"catalogued_tables": 5800, "total_tables": 6552, "good_edges": 
+52678, "total_edges": 60826, "phantom_edges": 12241, "blindspot_tables": 628, 
+"good_edges_strict": 48151, "edge_health_strict_pct": 79.16, 
+"good_edges_scoped": 37471, "total_edges_scoped": 38020, 
+"edge_health_scoped_pct": 98.56, "phantom_confirmed": 11701, 
+"phantom_contradicted": 352, "phantom_unverified": 188, "top_blindspot_tables": 
+[{"table": "ba.wtfa_kpi_datum_klant", "bad_edges": 70}, {"table": 
+"ba.wtfs_voorraad_dagstand", "bad_edges": 55}, {"table": 
+"ba.wtfs_voorraad_zondagstand", "bad_edges": 55}, {"table": 
+"da.rtgmd_postnl_customer_usage", "bad_edges": 43}, {"table": 
+"da.rtgmd_postnl_athome_3s", "bad_edges": 33}, {"table": 
+"wtfe_kpi_voorraad_artikel_voorraadlocatie", "bad_edges": 32}, {"table": 
+"da.rtgmd_postnl_facturen", "bad_edges": 30}, {"table": "da.hthyb_pages", 
+"bad_edges": 23}, {"table": "da.rtgmd_dhb_extra_kosten", "bad_edges": 19}, 
+{"table": "da.hthyb_page_brandplacement", "bad_edges": 17}], 
+"blindspot_tables_for_80pct": 17, "files_indexed": 1335, "indexed_sha": 
+"fdf1b551a34601a6cf3ce1c8b9f76e27ce2753e6", "db_path": "/tmp/mergec_after.db", 
+"index_timestamp": 1781470021.8137639, "degraded_parse_total": 5189, 
+"degraded_parse_queries": 27, "degraded_parse_by_dir": {"etl": {"degraded": 8, 
+"total": 2776}, "ddl": {"degraded": 19, "total": 2413}}, 
+"zero_edge_write_queries": 1028, "total_write_queries": 2323, 
+"cte_key_collisions": 0, "rescuable_unqualified_edges": 125, 
+"info_schema_has_column_rows": 100193, "cte_source_gap_writes": 0, 
+"resolvable_write_col_edges": 36936, "transitive_col_edges": 4178, 
+"qualify_failed_statements": 9, "tool_version_stale": false, 
+"indexed_tool_version": "1.35.2", "running_tool_version": "1.35.2"}}

sql_code_graph-1.35.2/plan/metrics/pr_c_merge_before.json

@@ -0,0 +1,31 @@
+{"total_calls": 1616, "last_7d_calls": 1616, "index_runs": 5, "feedback_tp": 0, 
+"feedback_total": 0, "top_tools": [{"name": "execute_sql", "count": 544}, 
+{"name": "trace_column_lineage", "count": 425}, {"name": 
+"list_dialects_and_repos", "count": 139}], "execute_sql_ratio": 0.34, 
+"parse_quality": {"sqlglot": 5166, "scripting": 20, "dynamic_sql": 3}, 
+"coverage": {"catalogued_tables": 5800, "total_tables": 6552, "good_edges": 
+52671, "total_edges": 60819, "phantom_edges": 12241, "blindspot_tables": 628, 
+"good_edges_strict": 48140, "edge_health_strict_pct": 79.15, 
+"good_edges_scoped": 37460, "total_edges_scoped": 38009, 
+"edge_health_scoped_pct": 98.56, "phantom_confirmed": 11701, 
+"phantom_contradicted": 352, "phantom_unverified": 188, "top_blindspot_tables": 
+[{"table": "ba.wtfa_kpi_datum_klant", "bad_edges": 70}, {"table": 
+"ba.wtfs_voorraad_dagstand", "bad_edges": 55}, {"table": 
+"ba.wtfs_voorraad_zondagstand", "bad_edges": 55}, {"table": 
+"da.rtgmd_postnl_customer_usage", "bad_edges": 43}, {"table": 
+"da.rtgmd_postnl_athome_3s", "bad_edges": 33}, {"table": 
+"wtfe_kpi_voorraad_artikel_voorraadlocatie", "bad_edges": 32}, {"table": 
+"da.rtgmd_postnl_facturen", "bad_edges": 30}, {"table": "da.hthyb_pages", 
+"bad_edges": 23}, {"table": "da.rtgmd_dhb_extra_kosten", "bad_edges": 19}, 
+{"table": "da.hthyb_page_brandplacement", "bad_edges": 17}], 
+"blindspot_tables_for_80pct": 17, "files_indexed": 1335, "indexed_sha": 
+"fdf1b551a34601a6cf3ce1c8b9f76e27ce2753e6", "db_path": "/tmp/mergec_before.db", 
+"index_timestamp": 1781469837.2725205, "degraded_parse_total": 5189, 
+"degraded_parse_queries": 20, "degraded_parse_by_dir": {"etl": {"degraded": 1, 
+"total": 2776}, "ddl": {"degraded": 19, "total": 2413}}, 
+"zero_edge_write_queries": 1034, "total_write_queries": 2323, 
+"cte_key_collisions": 0, "rescuable_unqualified_edges": 125, 
+"info_schema_has_column_rows": 100193, "cte_source_gap_writes": 0, 
+"resolvable_write_col_edges": 36936, "transitive_col_edges": 4182, 
+"qualify_failed_statements": 9, "tool_version_stale": false, 
+"indexed_tool_version": "1.35.1", "running_tool_version": "1.35.1"}}

{sql_code_graph-1.35.1 → sql_code_graph-1.35.2}/pyproject.toml

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

{sql_code_graph-1.35.1 → sql_code_graph-1.35.2}/src/sqlcg/__init__.py

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

{sql_code_graph-1.35.1 → sql_code_graph-1.35.2}/src/sqlcg/parsers/base.py

@@ -637,12 +637,14 @@ class SqlParser(ABC):
         """Return True if `_extract_column_lineage` would attempt extraction for `stmt`.
 
         Mirrors the type/body checks `_extract_column_lineage` (below, this class)
-        already performs: only `exp.Select`, `exp.Insert` with a `SELECT` body, and
-        `exp.Create` with a `Select`/`Subquery` body (CTAS / CREATE VIEW AS SELECT)
-        can ever produce column-lineage edges. `exp.Merge` is explicitly skipped there
-        (T-07-06, deferred). Everything else (Update, Delete, Use, Set, Comment, Drop,
-        Alter, Command, TruncateTable, CREATE ... LIKE/CLONE/column-defs, INSERT ...
-        VALUES) is structurally lineage-free regardless of `build_scope`'s outcome.
+        already performs: only `exp.Select`, `exp.Insert` with a `SELECT` body,
+        `exp.Create` with a `Select`/`Subquery` body (CTAS / CREATE VIEW AS SELECT),
+        and `exp.Merge` (column edges extracted structurally from its WHEN clauses —
+        see `_extract_merge_lineage`, plan/sprints/sprint_snowflake_lineage_patterns.md
+        PR-C) can ever produce column-lineage edges. Everything else (Update, Delete,
+        Use, Set, Comment, Drop, Alter, Command, TruncateTable, CREATE ...
+        LIKE/CLONE/column-defs, INSERT ... VALUES) is structurally lineage-free
+        regardless of `build_scope`'s outcome.
 
         Used by `AnsiParser._parse_statement` to avoid marking `parse_failed=True`
         for statement kinds that were never going to produce column lineage in the
@@ -658,8 +660,185 @@ class SqlParser(ABC):
             return isinstance(stmt.expression, exp.Select)
         if isinstance(stmt, exp.Create):
             return isinstance(stmt.expression, (exp.Select, exp.Subquery))
+        if isinstance(stmt, exp.Merge):
+            return True
         return False
 
+    def _extract_merge_lineage(
+        self,
+        stmt: Any,
+        dst_table: "TableRef | None",
+        query_sources: list["TableRef"] | None,
+        out: ParsedFile,
+    ) -> list[LineageEdge]:
+        """Extract column-level lineage from a MERGE statement's WHEN clauses.
+
+        MERGE column edges cannot come from sqlglot's ``lineage()`` (it does not model
+        MERGE branches), but the ``WHEN MATCHED ... UPDATE SET`` and
+        ``WHEN NOT MATCHED ... INSERT (cols) VALUES (vals)`` clauses are structurally
+        extractable by a direct AST walk. This method performs that walk: it is bounded
+        and runs ONCE PER MERGE statement — it NEVER calls ``sg_lineage``, ``qualify``,
+        ``build_scope`` or ``exp.expand`` (AC-C7,
+        plan/sprints/sprint_snowflake_lineage_patterns.md PR-C).
+
+        Resolution model:
+        - The MERGE target (``stmt.this``) and source (``stmt.args['using']``) are both
+          captured in ``query_sources`` as already-qualified TableRefs (the table-grain
+          path does NOT split them into target/sources for MERGE — ``dst_table`` is
+          ``None`` here, so AC-C3's shipped table-grain behaviour is preserved). This
+          method matches ``stmt.this``/``using`` back to those refs by alias+name to
+          identify which is the target and which the source(s), then builds an
+          alias -> TableRef map over both.
+        - MATCHED UPDATE: each ``exp.EQ`` is ``target_col = source_expr``; the dst is a
+          column on the target, the src columns are every ``exp.Column`` in the RHS
+          (multi-source expressions emit one edge per source column — AC-C4). A
+          pure-literal RHS (no ``exp.Column``) contributes no edge (AC-C5) — mirrors the
+          pure-literal skip invariant.
+        - NOT MATCHED INSERT: ``then.this`` is the target column tuple, ``then.expression``
+          the values tuple; zip positionally and emit per source column. An INSERT with
+          no column list (``then.this is None``) is skip-and-logged
+          (``col_lineage_skip:merge_no_collist:``) — NO positional DDL fallback (gate
+          decision: positional guessing risks wrong edges).
+
+        Args:
+            stmt: the ``exp.Merge`` AST node.
+            dst_table: the resolved INSERT/CREATE target TableRef from the caller. For
+                MERGE this is ``None`` (the table-grain path leaves the target in
+                ``query_sources``); the target is recovered here from ``stmt.this``.
+            query_sources: resolved table refs for the MERGE (target + ``USING``
+                source(s)), each carrying its ``.alias``, fully qualified.
+            out: ParsedFile, for skip/unresolved error records.
+
+        Returns:
+            List of LineageEdge (may be empty).
+        """
+        import sqlglot.expressions as exp
+
+        edges: list[LineageEdge] = []
+        refs = list(query_sources or [])
+        if dst_table is not None:
+            refs.append(dst_table)
+
+        # Identify the MERGE target ref by matching stmt.this against the resolved refs.
+        # `_real_tables` does not preserve the AST alias on the TableRef, so match on the
+        # AST target's name (and alias, as a fallback) against each ref's name/alias.
+        # The remaining refs are the USING source(s).
+        target_ast = stmt.this if isinstance(stmt.this, exp.Table) else None
+        target_keys: set[str] = set()
+        if target_ast is not None:
+            if target_ast.name:
+                target_keys.add(target_ast.name.lower())
+            if target_ast.alias:
+                target_keys.add(target_ast.alias.lower())
+
+        def _ref_keys(ref: TableRef) -> set[str]:
+            keys: set[str] = set()
+            if ref.alias:
+                keys.add(ref.alias.lower())
+            if ref.name:
+                keys.add(ref.name.lower())
+            return keys
+
+        target_ref: TableRef | None = None
+        if target_keys:
+            for ref in refs:
+                if target_keys & _ref_keys(ref):
+                    target_ref = ref
+                    break
+        if target_ref is None:
+            label = ".".join(sorted(target_keys)) or "<unknown>"
+            out.errors.append(f"col_lineage_skip:merge_no_target:{label}")
+            return edges
+
+        source_refs = [r for r in refs if r is not target_ref]
+
+        # Build an alias/name -> TableRef map over the target + USING source(s).
+        # MERGE column references qualify by the table alias (e.g. `target.name`,
+        # `s.name`). `_real_tables` strips the alias from the resolved TableRef, so the
+        # alias is recovered from the AST nodes (target=stmt.this, source=using) and
+        # mapped to its resolved ref. Bare table names are registered as a fallback.
+        alias_map: dict[str, TableRef] = {}
+
+        def _register(ref: TableRef | None, ast_node: Any) -> None:
+            if ref is None:
+                return
+            if isinstance(ast_node, exp.Table) and ast_node.alias:
+                alias_map.setdefault(ast_node.alias.lower(), ref)
+            if ref.alias:
+                alias_map.setdefault(ref.alias.lower(), ref)
+            if ref.name:
+                alias_map.setdefault(ref.name.lower(), ref)
+
+        using_ast = stmt.args.get("using")
+        _register(target_ref, target_ast)
+        for src in source_refs:
+            _register(src, using_ast if len(source_refs) == 1 else None)
+
+        def _resolve_table(col: Any) -> TableRef | None:
+            """Resolve the owning TableRef of a source column reference."""
+            tbl_name = col.table
+            if tbl_name:
+                return alias_map.get(tbl_name.lower())
+            # Unqualified RHS column — attribute to the lone source when unambiguous.
+            if len(source_refs) == 1:
+                return source_refs[0]
+            return None
+
+        def _emit(target_col_name: str, rhs: Any, transform: str) -> None:
+            """Emit one edge per source ``exp.Column`` found in ``rhs``."""
+            if not target_col_name:
+                return
+            cols = list(rhs.find_all(exp.Column)) if rhs is not None else []
+            if not cols:
+                # Pure-literal / no source column — no edge (AC-C5).
+                return
+            dst_ref = ColumnRef(table=target_ref, name=target_col_name)
+            for col in cols:
+                src_table = _resolve_table(col)
+                if src_table is None:
+                    out.errors.append(
+                        f"col_lineage_skip:merge_unresolved:{col.table or ''}.{col.name}"
+                    )
+                    continue
+                edges.append(
+                    LineageEdge(
+                        src=ColumnRef(table=src_table, name=col.name),
+                        dst=dst_ref,
+                        transform=transform,
+                    )
+                )
+
+        for when in stmt.find_all(exp.When):
+            then = when.args.get("then")
+            if isinstance(then, exp.Update):
+                # WHEN MATCHED THEN UPDATE SET target.a = s.a, target.b = s.x + s.y
+                for eq in then.expressions:
+                    if not isinstance(eq, exp.EQ):
+                        continue
+                    lhs = eq.this
+                    if not isinstance(lhs, exp.Column):
+                        continue
+                    _emit(lhs.name, eq.expression, "MERGE_UPDATE")
+            elif isinstance(then, exp.Insert):
+                # WHEN NOT MATCHED THEN INSERT (cols) VALUES (vals)
+                target_cols = then.this
+                values = then.expression
+                if target_cols is None:
+                    # INSERT VALUES with no column list — skip-and-log, no positional
+                    # DDL fallback (gate decision: positional guessing risks wrong edges).
+                    out.errors.append(f"col_lineage_skip:merge_no_collist:{target_ref.full_id}")
+                    continue
+                col_exprs = list(getattr(target_cols, "expressions", []) or [])
+                val_exprs = list(getattr(values, "expressions", []) or [])
+                # Positional alignment of (cols) with VALUES (...); a malformed MERGE
+                # with mismatched arities zips to the shorter list rather than raising.
+                for target_col, value in zip(col_exprs, val_exprs, strict=False):
+                    if not isinstance(target_col, exp.Column):
+                        continue
+                    _emit(target_col.name, value, "MERGE_INSERT")
+
+        return edges
+
     def _real_tables(self, scope: Any) -> list[TableRef]:
         """Return real (non-CTE) tables referenced in a scope.
 
@@ -1117,19 +1296,15 @@ class SqlParser(ABC):
         join_col_resolves: list[JoinColResolve] = []
         _qualify_failed: bool = False
 
-        # NEW (T-07-06): Record MERGE statements explicitly as deferred.
-        # sqlglot's lineage() API does not handle MERGE branches; implementing
-        # multi-branch lineage is deferred (see plan/sprints/sprint_07_open_ecodes.md § T-07-06).
-        # TODO: Remove when sqlglot adds MERGE lineage support (T-07-06).
+        # MERGE column lineage (un-defer T-07-06,
+        # plan/sprints/sprint_snowflake_lineage_patterns.md PR-C). sqlglot's lineage()
+        # API does not handle MERGE branches, but the WHEN MATCHED UPDATE SET / WHEN NOT
+        # MATCHED INSERT VALUES clauses are structurally extractable by a direct AST walk.
+        # This is a bounded once-per-statement path that NEVER calls sg_lineage / qualify /
+        # build_scope / exp.expand (AC-C7).
         if isinstance(stmt, exp.Merge):
-            dst_name = None
-            if stmt.this is not None:
-                try:
-                    dst_name = stmt.this.name
-                except Exception:
-                    dst_name = None
-            out.errors.append(f"col_lineage_skip:merge_branch:{dst_name or '<unknown>'}")
-            return LineageExtraction(edges=edges, star_sources=star_sources)
+            merge_edges = self._extract_merge_lineage(stmt, dst_table, query_sources, out)
+            return LineageExtraction(edges=merge_edges, star_sources=star_sources)
 
         # Only extract column lineage for certain statement types
         if not isinstance(stmt, (exp.Select, exp.Insert, exp.Create)):

sql_code_graph-1.35.2/src/sqlcg/parsers/dynamic_name.py

@@ -0,0 +1,170 @@
+"""Dialect-agnostic bounded constant-fold of dynamic table-name expressions.
+
+This is the pure core of the "generic variable-name resolution" feature
+(``plan/sprints/feature_generic_var_name_resolution.md``). It partially folds a
+string-valued expression AST (string literals, ``||`` / ``CONCAT``, and 1-hop
+``$var`` references) into a concrete ``[catalog.]db.name`` table reference,
+recovering the statically-determined trailing identifier components while
+honestly giving up when the name cannot be determined.
+
+No parser/indexer state is touched here: ``resolve_dynamic_name`` is a pure
+function, fully unit-testable in isolation. PR-2 wires it into the Snowflake
+parser via a sink predicate; this module ships unwired.
+
+Fold classification:
+
+* **LIT (resolvable):** ``exp.Literal`` (string), ``exp.DPipe`` / ``exp.Concat``
+  over folds, and a 1-hop ``$var`` whose RHS (looked up in ``var_env`` exactly
+  once) itself folds to a leading constant prefix.
+* **OPAQUE (unresolvable):** runtime functions (``current_database()``,
+  ``split_part(...)``, ``current_warehouse()``, any ``exp.Func`` /
+  ``exp.Anonymous`` that is not a pure string op), scalar subqueries that are not
+  a single-projection of folds, bind parameters (``exp.Placeholder``), and any
+  ``$var`` reference at chain depth >= 2.
+
+Name extraction interprets the fold as ``[catalog.]db.name`` (name-last,
+dot-split): it keeps the rightmost statically-determined ``db.name`` tail,
+wildcards (drops) a leading OPAQUE catalog, keeps a static *literal* catalog, and
+returns ``None`` when the whole thing is opaque / the tail is a bare name / the
+tail lacks a resolvable ``db.name``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import sqlglot.expressions as exp
+
+
+@dataclass(frozen=True)
+class _Lit:
+    """A statically-known string segment of the folded expression."""
+
+    text: str
+
+
+@dataclass(frozen=True)
+class _Opaque:
+    """A runtime-determined segment that cannot be folded statically."""
+
+
+_Part = _Lit | _Opaque
+
+
+def _fold_parts(
+    node: exp.Expression,  # type: ignore[attr-defined]
+    var_env: dict[str, exp.Expression],  # type: ignore[attr-defined]
+    *,
+    chain_depth: int,
+) -> list[_Part]:
+    """Fold ``node`` into an ordered list of LIT / OPAQUE parts.
+
+    Descends string-concatenation structure (``||`` / ``CONCAT``), single-
+    projection subqueries and parentheses; resolves 1-hop ``$var`` references
+    against ``var_env``; classifies everything else OPAQUE.
+    """
+    # Unwrap a single-projection (SELECT ...) scalar subquery / paren.
+    if isinstance(node, exp.Subquery):
+        return _fold_parts(node.this, var_env, chain_depth=chain_depth)
+    if isinstance(node, exp.Paren):
+        return _fold_parts(node.this, var_env, chain_depth=chain_depth)
+    if isinstance(node, exp.Select):
+        projections = node.expressions
+        if len(projections) != 1:
+            return [_Opaque()]
+        return _fold_parts(projections[0], var_env, chain_depth=chain_depth)
+
+    # String concatenation: DPipe is binary (left-nested), Concat is n-ary.
+    if isinstance(node, exp.DPipe):
+        return _fold_parts(node.this, var_env, chain_depth=chain_depth) + _fold_parts(
+            node.expression, var_env, chain_depth=chain_depth
+        )
+    if isinstance(node, exp.Concat):
+        parts: list[_Part] = []
+        for child in node.expressions:
+            parts.extend(_fold_parts(child, var_env, chain_depth=chain_depth))
+        return parts
+
+    # Concrete string literal.
+    if isinstance(node, exp.Literal) and node.is_string:
+        return [_Lit(node.this)]
+
+    # 1-hop $var reference.
+    if isinstance(node, exp.Parameter):
+        var = node.this
+        name = var.name if isinstance(var, exp.Var) else None
+        if name is None or chain_depth < 1:
+            return [_Opaque()]
+        rhs = var_env.get(name.lower())
+        if rhs is None:
+            return [_Opaque()]
+        # Resolve exactly one hop: the looked-up RHS may not itself follow
+        # further $vars (depth-2 is OPAQUE because chain_depth drops to 0).
+        return _fold_parts(rhs, var_env, chain_depth=chain_depth - 1)
+
+    # Everything else (runtime funcs, bind params, non-fold subqueries) is opaque.
+    return [_Opaque()]
+
+
+def resolve_dynamic_name(
+    rhs_expr: exp.Expression,  # type: ignore[attr-defined]
+    var_env: dict[str, exp.Expression],  # type: ignore[attr-defined]
+    *,
+    chain_depth: int = 1,
+) -> exp.Table | None:
+    """Bounded partial constant-fold of a string-expression AST into a TableRef.
+
+    Args:
+        rhs_expr: the RHS expression assigned to the dynamic name (the AST that
+            the ``IDENTIFIER($var)`` sink dereferences).
+        var_env: lowercased var name -> its RHS AST, for 1-hop chain resolution.
+        chain_depth: max var-lookup hops (default 1; corpus max is 1). A var
+            whose value references another var resolves only the first hop.
+
+    Returns:
+        An ``exp.Table`` for the resolvable trailing identifier components, or
+        ``None`` to give up honestly (caller leaves the sink dropped).
+    """
+    parts = _fold_parts(rhs_expr, var_env, chain_depth=chain_depth)
+
+    if not parts:
+        return None
+
+    # Take the rightmost contiguous run of LIT parts (the static suffix), noting
+    # whether an OPAQUE segment sits immediately before that run (catalog
+    # position is then runtime-determined).
+    suffix_lits: list[str] = []
+    opaque_precedes_suffix = False
+    for part in reversed(parts):
+        if isinstance(part, _Lit):
+            suffix_lits.append(part.text)
+        else:
+            opaque_precedes_suffix = True
+            break
+    suffix_lits.reverse()
+
+    if not suffix_lits:
+        # All-opaque (no static tail at all).
+        return None
+
+    suffix = "".join(suffix_lits)
+    table = exp.to_table(suffix, dialect="snowflake")
+
+    # A resolvable object id needs at least db.name (schema.table). A bare name
+    # (no db) is a give-up: we never guess the schema/table. A missing name (tail
+    # ends on a dot) is likewise unresolvable.
+    if table.db == "" or table.name == "":
+        return None
+
+    # Catalog policy:
+    #   - literal catalog present in the static suffix (3-part name) -> KEEP it.
+    #   - an OPAQUE segment precedes the suffix (the catalog slot came from a
+    #     runtime segment) -> wildcard / drop the catalog (emit catalog-less
+    #     db.name) so the node merges with DDL / plain-SQL refs to the same table.
+    # to_table already yields catalog='' when the static suffix had no catalog
+    # component (e.g. '.EMP.APPLICATION_FIELDS' or 'DHB.KOSTEN'); the explicit
+    # drop only matters when an opaque prefix sits before a literal 3-part tail.
+    if opaque_precedes_suffix and table.catalog != "":
+        table.set("catalog", None)
+
+    return table

{sql_code_graph-1.35.1 → sql_code_graph-1.35.2}/tests/integration/test_skip_counts_integration.py

@@ -181,15 +181,17 @@ def test_skip_counts_queryable_across_corpus(db, tmp_path):
 def test_skip_counts_index_full_file_populates_column(db, tmp_path):
     """Indexing a real SQL file through the full index_repo path persists skip_counts.
 
-    Uses a Snowflake SQL fixture with a MERGE statement (guaranteed to emit
-    col_lineage_skip:merge_branch:*) to verify the end-to-end path from parse
-    → normalize_keys → _build_file_rows → upsert_nodes_bulk → File.skip_counts.
+    Uses a Snowflake SQL fixture with a MERGE whose NOT MATCHED INSERT omits a column
+    list (guaranteed to emit col_lineage_skip:merge_no_collist:* — see
+    plan/sprints/sprint_snowflake_lineage_patterns.md PR-C) to verify the end-to-end
+    path from parse → normalize_keys → _build_file_rows → upsert_nodes_bulk →
+    File.skip_counts.
     """
-    # MERGE statements emit col_lineage_skip:merge_branch:*
+    # A no-column-list MERGE INSERT emits col_lineage_skip:merge_no_collist:*
     sql = (
         "CREATE TABLE src (a INT, b INT);\n"
         "MERGE INTO tgt USING src ON tgt.a = src.a\n"
-        "WHEN MATCHED THEN UPDATE SET tgt.b = src.b;\n"
+        "WHEN NOT MATCHED THEN INSERT VALUES (src.a, src.b);\n"
     )
     sql_file = tmp_path / "merge_fixture.sf.sql"
     sql_file.write_text(sql)
@@ -201,15 +203,15 @@ def test_skip_counts_index_full_file_populates_column(db, tmp_path):
         {"path": str(sql_file)},
     )
     assert len(rows) == 1, f"File row not found for {sql_file}"
-    # MERGE emits at least one merge_branch skip
+    # The no-collist MERGE INSERT emits at least one merge_no_collist skip
     raw = rows[0]["skip_counts"]
     assert raw is not None, (
-        "skip_counts must be non-null for a file containing a MERGE statement "
-        f"(expected col_lineage_skip:merge_branch:*). Got NULL. File: {sql_file}"
+        "skip_counts must be non-null for a file containing a no-collist MERGE INSERT "
+        f"(expected col_lineage_skip:merge_no_collist:*). Got NULL. File: {sql_file}"
     )
     counts = json.loads(raw)
-    assert counts.get("merge_branch", 0) >= 1, (
-        f"Expected merge_branch >= 1 in skip_counts. Got {counts!r}"
+    assert counts.get("merge_no_collist", 0) >= 1, (
+        f"Expected merge_no_collist >= 1 in skip_counts. Got {counts!r}"
     )
 
 

sql_code_graph-1.35.2/tests/snowflake/E16/test_e16.py

@@ -0,0 +1,59 @@
+"""E16: MERGE multi-branch column lineage (structural extraction).
+
+MERGE statements now produce column lineage via a direct AST walk of their
+``WHEN MATCHED ... UPDATE SET`` / ``WHEN NOT MATCHED ... INSERT (cols) VALUES (...)``
+clauses — sqlglot's ``lineage()`` API does not visit MERGE branches, so this is a
+dedicated structural path (no ``sg_lineage`` / ``qualify``).
+
+Un-defers the E16/T-07-06 deferral. See
+plan/sprints/sprint_snowflake_lineage_patterns.md PR-C
+([plan doc](../../../plan/sprints/sprint_snowflake_lineage_patterns.md)) and the
+E{n} taxonomy (plan/sprints/sprint_07_open_ecodes.md § T-07-06) for history.
+"""
+
+from pathlib import Path
+
+from tests.snowflake.conftest import edges, parse
+
+
+def test_e16_merge_match_and_insert(parser):
+    """MATCHED UPDATE and NOT MATCHED INSERT each emit a column edge.
+
+    `UPDATE SET col = src.col_a` -> `src.col_a -> dst.col` (MERGE_UPDATE);
+    `INSERT (col) VALUES (src.col_b)` -> `src.col_b -> dst.col` (MERGE_INSERT).
+    """
+    sql = Path(__file__).with_name("e16_merge.sql").read_text()
+    result = parse(parser, sql, "e16_merge.sql")
+
+    all_edges = set(edges(result))
+    assert ("src", "col_a", "dst", "col") in all_edges, (
+        f"E16: MATCHED UPDATE edge missing; got {all_edges}"
+    )
+    assert ("src", "col_b", "dst", "col") in all_edges, (
+        f"E16: NOT MATCHED INSERT edge missing; got {all_edges}"
+    )
+
+    # No deferred-skip noise should remain for an extractable MERGE.
+    assert not any("col_lineage_skip:merge_branch" in e for e in result.errors), (
+        f"MERGE no longer defers; got errors: {result.errors}"
+    )
+
+
+def test_e16_merge_delete(parser):
+    """A DELETE branch yields no edge; the UPDATE/INSERT branches still do.
+
+    `WHEN MATCHED ... THEN DELETE` has no column assignment, so it contributes no
+    edge, while the MATCHED UPDATE and NOT MATCHED INSERT branches still resolve.
+    """
+    sql = Path(__file__).with_name("e16_merge_delete.sql").read_text()
+    result = parse(parser, sql, "e16_merge_delete.sql")
+
+    all_edges = set(edges(result))
+    assert ("src", "col_a", "dst", "col") in all_edges, (
+        f"E16: MATCHED UPDATE edge missing alongside DELETE branch; got {all_edges}"
+    )
+    assert ("src", "col_b", "dst", "col") in all_edges, (
+        f"E16: NOT MATCHED INSERT edge missing alongside DELETE branch; got {all_edges}"
+    )
+    # The DELETE branch assigns no column, so it must not add a phantom edge.
+    assert len(all_edges) == 2, f"E16: DELETE branch should add no edge; got {all_edges}"

{sql_code_graph-1.35.1 → sql_code_graph-1.35.2}/tests/snowflake/test_plan_review_gates.py

@@ -60,14 +60,14 @@ def test_plan_review_e3_ddl_quality_allows_scripting_fallback():
 
 
 # ---------------------------------------------------------------------------
-# BLOCKER-2 (E16): MERGE produces zero column lineage — not "at least one edge"
+# BLOCKER-2 (E16): MERGE now produces column lineage (T-07-06 un-deferred)
 # ---------------------------------------------------------------------------
-def test_plan_review_e16_merge_produces_zero_edges():
-    """E16 MERGE must produce zero high-confidence edges (current state).
+def test_plan_review_e16_merge_captures_both_branches():
+    """E16 MERGE captures both the MATCHED UPDATE and NOT MATCHED INSERT branches.
 
-    The original plan asserted 'at least one edge exists', which is wrong —
-    MERGE statements produce no column_lineage. This test gates the corrected
-    zero-edge assertion with INVERSION TARGET.
+    This is the inversion of the earlier zero-edge gate: MERGE column lineage is
+    now extracted structurally (plan/sprints/sprint_snowflake_lineage_patterns.md
+    PR-C), so both branches resolve src col_a / col_b -> dst.col.
     """
     p = _parser()
     sql = (
@@ -77,12 +77,9 @@ def test_plan_review_e16_merge_produces_zero_edges():
     )
     result = p.parse_file(Path("test_e16.sql"), sql)
 
-    # INVERSION TARGET: when E16 fixed, assert edges with dst_table=="DST"
-    # and srcs == {"COL_A", "COL_B"} (both branches captured).
-    assert _edges(result) == [], (
-        "E16: MERGE currently produces no column lineage; "
-        "if this fails, E16 was partially fixed and the test must be updated"
-    )
+    edges = set(_edges(result))
+    assert ("src", "col_a", "dst", "col") in edges, edges
+    assert ("src", "col_b", "dst", "col") in edges, edges
 
 
 # ---------------------------------------------------------------------------