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

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

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

sql_code_graph-1.35.1/plan/metrics/pr_b_phantom_after.json

@@ -0,0 +1,32 @@
+{"total_calls": 1476, "last_7d_calls": 1476, "index_runs": 5, "feedback_tp": 0, 
+"feedback_total": 0, "top_tools": [{"name": "execute_sql", "count": 496}, 
+{"name": "trace_column_lineage", "count": 389}, {"name": 
+"list_dialects_and_repos", "count": 127}], "execute_sql_ratio": 0.34, 
+"parse_quality": {"sqlglot": 5166, "scripting": 20, "dynamic_sql": 3}, 
+"coverage": {"catalogued_tables": 5800, "total_tables": 6552, "good_edges": 
+52657, "total_edges": 60805, "phantom_edges": 12241, "blindspot_tables": 628, 
+"good_edges_strict": 48140, "edge_health_strict_pct": 79.17, 
+"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/sqlcg-gain-after.db", "index_timestamp": 1781466521.041257, 
+"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": 4168, "qualify_failed_statements": 9, 
+"tool_version_stale": false, "indexed_tool_version": "1.34.5", 
+"running_tool_version": "1.34.5"}}

sql_code_graph-1.35.1/plan/metrics/pr_b_phantom_before.json

@@ -0,0 +1,32 @@
+{"total_calls": 1476, "last_7d_calls": 1476, "index_runs": 5, "feedback_tp": 0, 
+"feedback_total": 0, "top_tools": [{"name": "execute_sql", "count": 496}, 
+{"name": "trace_column_lineage", "count": 389}, {"name": 
+"list_dialects_and_repos", "count": 127}], "execute_sql_ratio": 0.34, 
+"parse_quality": {"sqlglot": 5166, "scripting": 20, "dynamic_sql": 3}, 
+"coverage": {"catalogued_tables": 5800, "total_tables": 6581, "good_edges": 
+52669, "total_edges": 60817, "phantom_edges": 12241, "blindspot_tables": 628, 
+"good_edges_strict": 48140, "edge_health_strict_pct": 79.16, 
+"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/sqlcg-gain-before.db", "index_timestamp": 1781466329.8251324, 
+"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": 4180, "qualify_failed_statements": 9, 
+"tool_version_stale": false, "indexed_tool_version": "1.34.4", 
+"running_tool_version": "1.34.4"}}

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

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

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

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

{sql_code_graph-1.35.0 → sql_code_graph-1.35.1}/src/sqlcg/parsers/ansi_parser.py

@@ -551,25 +551,44 @@ class AnsiParser(SqlParser):
         # measurement artifact (96.1%/4,544 of 4,727 on the DWH corpus).
         can_have_lineage = self._can_have_column_lineage(stmt)
 
+        # Phantom source-node gate (#161): a non-table/non-view CREATE
+        # (SEQUENCE / STAGE / FILE FORMAT / SCHEMA / INDEX / PROCEDURE / ...) has
+        # target=None and no data-flow source. Its only Table node is its own
+        # object name, which _fallback_table_scan below would otherwise scoop into
+        # `sources`, leaking a phantom SqlTable SOURCE node + SELECTS_FROM edge
+        # into the graph. #159 fixed the kind LABEL (-> OTHER); this closes the
+        # source-node half. Keying off stmt.kind (the sqlglot AST value, e.g.
+        # 'SEQUENCE') keeps the gate independent of the _classify/QueryKind path.
+        # CREATE TABLE/VIEW ... AS SELECT keep kind in (TABLE, VIEW) and so retain
+        # their real sources. Real procedure lineage comes from the spliced inner
+        # DML (a separate node the gate never touches), so gating PROCEDURE is
+        # edge-neutral. This single gate feeds all three
+        # `referenced_tables.extend(query_node.sources)` sites
+        # (ansi_parser.py:246, snowflake_parser.py:784 / :944).
+        is_non_table_create = isinstance(stmt, exp.Create) and stmt.kind not in ("TABLE", "VIEW")
+
         # Try to extract table references using scope analysis
         try:
-            # Use pre-built scope if provided, otherwise build it here (fallback)
-            root_scope = scope
-            if root_scope is None:
-                from sqlglot.optimizer.scope import build_scope
-
-                root_scope = build_scope(stmt)
-
-            if root_scope:
-                sources = self._real_tables(root_scope)
+            if is_non_table_create:
+                sources = []
             else:
-                # Fallback to basic table extraction
-                sources = [
-                    r
-                    for s in self._fallback_table_scan(stmt)
-                    if (r := self._apply_table_alias(s)) is not None
-                ]
-                parse_failed = can_have_lineage
+                # Use pre-built scope if provided, otherwise build it here (fallback)
+                root_scope = scope
+                if root_scope is None:
+                    from sqlglot.optimizer.scope import build_scope
+
+                    root_scope = build_scope(stmt)
+
+                if root_scope:
+                    sources = self._real_tables(root_scope)
+                else:
+                    # Fallback to basic table extraction
+                    sources = [
+                        r
+                        for s in self._fallback_table_scan(stmt)
+                        if (r := self._apply_table_alias(s)) is not None
+                    ]
+                    parse_failed = can_have_lineage
         except Exception as exc:
             logger.debug("Failed to build scope for statement %d in %s: %s", stmt_index, path, exc)
             sources = [

{sql_code_graph-1.35.0 → sql_code_graph-1.35.1}/tests/integration/test_non_table_create_kind_in_graph.py

@@ -10,11 +10,14 @@ Scope (RESCOPED, kind-only — plan §Scope):
   * AC3 — the ``analyze impact`` query (analyze.py:317 shape) renders the
     sequence's producing statement as ``kind=OTHER`` not ``CREATE_TABLE``.
 
-Explicitly OUT OF SCOPE (plan Follow-up §, blast-radius row #1b): the sequence
-name persists as a ``SqlTable`` source node via the kind-independent
-``referenced_tables`` → ``indexer.py`` source loop. This fix corrects only the
-stored kind; it does NOT remove that phantom node. No assertion here claims the
-node is absent.
+Originally OUT OF SCOPE for #159 (plan Follow-up §, blast-radius row #1b): the
+sequence name persisted as a ``SqlTable`` source node via the kind-independent
+``referenced_tables`` → ``indexer.py`` source loop. **That phantom node has since
+been removed by the PR-B source-gate (#161)**
+([plan doc](plan/sprints/sprint_snowflake_lineage_patterns.md)). The two tests
+below that previously asserted the phantom SELECTS_FROM edge / ``ba.s`` node
+*exists* have been flipped to assert its *absence* — the corrected post-#161
+graph shape. The kind-only assertions (AC1/AC2) are unchanged.
 """
 
 import pytest
@@ -87,13 +90,14 @@ def test_ctas_still_create_table(indexed, db):
     )
 
 
-def test_sequence_produces_selects_from_edge(indexed, db):
-    """The sequence statement carries a SELECTS_FROM edge to its name node.
+def test_sequence_produces_no_phantom_selects_from_edge(indexed, db):
+    """Post-#161: the sequence statement carries NO phantom SELECTS_FROM edge.
 
-    This is the live shape behind the bug — a non-table CREATE that has a
-    SELECTS_FROM edge yet was mislabeled CREATE_TABLE. Asserting the edge exists
-    proves the reclassified statement is exactly the kind that leaked into
-    ``analyze impact`` (NOT a statement with no edges).
+    Before PR-B (#161) the sequence's own name ``ba.s`` was scooped into
+    ``sources`` and emitted as a ``SELECTS_FROM`` edge from the producing
+    statement to a phantom ``ba.s`` SqlTable node. The source-gate suppresses
+    this, so no SELECTS_FROM edge points at ``ba.s`` any longer. (Flipped from the
+    pre-#161 assertion that the edge existed — see module docstring.)
     """
     rows = db.run_read(
         'SELECT q.id AS id, q.kind AS kind FROM "SqlQuery" q '
@@ -101,21 +105,28 @@ def test_sequence_produces_selects_from_edge(indexed, db):
         "WHERE sf.dst_key = ?",
         {"dst": "ba.s"},
     )
-    assert len(rows) == 1, f"expected one SELECTS_FROM producer for ba.s, got {rows}"
-    assert rows[0]["kind"] == "OTHER", (
-        f"the sequence statement with a SELECTS_FROM edge must be kind=OTHER, "
-        f"got {rows[0]['kind']!r}"
-    )
+    assert rows == [], f"phantom SELECTS_FROM edge to ba.s should be gone, got {rows}"
 
 
-def test_analyze_impact_renders_sequence_as_other(indexed, db, monkeypatch):
-    """AC3: ``analyze impact ba.s`` renders the producing statement kind=OTHER.
+def test_sequence_name_is_not_a_sqltable_node(indexed, db):
+    """Post-#161: the sequence object name is not emitted as a SqlTable node.
 
-    Runs the exact analyze.py:317 query shape against the indexed graph and the
-    CLI render path; asserts the kind column shows OTHER, never CREATE_TABLE.
-    No assertion is made about the ba.s SqlTable node's existence (out of scope).
+    The phantom ``ba.s`` SqlTable node previously created by the kind-independent
+    source loop is removed by the PR-B source-gate (#161).
     """
-    # Direct query (analyze.py:317 shape) — observable kind on the producer row.
+    rows = db.run_read('SELECT qualified FROM "SqlTable" WHERE qualified = ?', {"q": "ba.s"})
+    assert rows == [], f"phantom SqlTable node ba.s should be gone, got {rows}"
+
+
+def test_analyze_impact_sequence_node_absent(indexed, db, monkeypatch):
+    """Post-#161: ``analyze impact ba.s`` finds no phantom producer.
+
+    The phantom ``ba.s`` node and its SELECTS_FROM edge are removed, so the
+    analyze.py:317 query shape returns no rows for ``ba.s`` and the CLI never
+    renders a CREATE_TABLE (or any) producer for it. (Flipped from the pre-#161
+    assertion that the producer rendered as OTHER — see module docstring.)
+    """
+    # Direct query (analyze.py:317 shape) — no producer row for the phantom node.
     results = db.run_read(
         "SELECT DISTINCT q.id AS id, q.kind AS kind, q.target_table AS target"
         ' FROM "SqlTable" t'
@@ -124,12 +135,9 @@ def test_analyze_impact_renders_sequence_as_other(indexed, db, monkeypatch):
         " WHERE t.qualified = ? LIMIT 100",
         {"t": "ba.s"},
     )
-    kinds = {r["kind"] for r in results}
-    assert kinds == {"OTHER"}, (
-        f"analyze impact on ba.s must render only kind=OTHER for the sequence producer; got {kinds}"
-    )
+    assert results == [], f"no producer should resolve via the removed phantom ba.s; got {results}"
 
-    # CLI render path: kind=OTHER appears, CREATE_TABLE does not.
+    # CLI render path: CREATE_TABLE must not be rendered for the sequence.
     from typer.testing import CliRunner
 
     from sqlcg.cli.commands.analyze import app
@@ -140,9 +148,6 @@ def test_analyze_impact_renders_sequence_as_other(indexed, db, monkeypatch):
     monkeypatch.setattr("sqlcg.cli.commands.analyze.run_read_routed", _route_to_db)
     result = CliRunner().invoke(app, ["impact", "ba.s", "--raw"])
     assert result.exit_code == 0, result.output
-    assert "OTHER" in result.output, (
-        f"analyze impact output must contain kind=OTHER for the sequence.\n{result.output}"
-    )
     assert "CREATE_TABLE" not in result.output, (
         f"analyze impact must NOT render CREATE_TABLE for the sequence.\n{result.output}"
     )

sql_code_graph-1.35.1/tests/integration/test_phantom_non_table_create_node.py

@@ -0,0 +1,80 @@
+"""Non-table CREATE objects must not become SqlTable nodes / SELECTS_FROM edges.
+
+Guards the phantom-source-node bugfix (#161)
+([plan doc](plan/sprints/sprint_snowflake_lineage_patterns.md), PR-B).
+
+#159 fixed the kind label; the phantom SOURCE node persisted. For a
+`CREATE SEQUENCE ba.s` the object's own name was scooped into
+`QueryNode.sources` and then leaked into the graph as a `SqlTable` node with a
+`SELECTS_FROM` edge. The source-gate in `AnsiParser._parse_statement` suppresses
+this. This integration test indexes a mixed fixture and asserts on the resulting
+graph structure (observable output), confirming:
+
+- the SEQUENCE / STAGE / FILE FORMAT names are NOT SqlTable nodes and have NO
+  SELECTS_FROM edge;
+- a real `INSERT INTO ba.t SELECT ... FROM ba.real` keeps its `ba.real -> ba.t`
+  lineage (gate edge-neutral for real tables).
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from sqlcg.core.duckdb_backend import DuckDBBackend
+from sqlcg.indexer.indexer import Indexer
+
+# A non-table CREATE batch + a genuine INSERT...SELECT control, one file.
+_FIXTURE_SQL = """\
+CREATE SEQUENCE IF NOT EXISTS ba.wsdh_s1;
+CREATE STAGE ba.msstg_ingest URL='s3://bucket/x';
+CREATE FILE FORMAT ba.msfmt_parquet TYPE=PARQUET;
+INSERT INTO ba.t SELECT a FROM ba.real;
+"""
+
+_PHANTOM_NAMES = ("ba.wsdh_s1", "ba.msstg_ingest", "ba.msfmt_parquet")
+
+
+@pytest.fixture
+def db():
+    """Fresh in-memory DuckDB backend with schema initialised."""
+    backend = DuckDBBackend(":memory:")
+    backend.init_schema()
+    yield backend
+    backend.close()
+
+
+def _table_nodes(db: DuckDBBackend) -> set[str]:
+    rows = db.run_read('SELECT qualified FROM "SqlTable"', {})
+    return {r["qualified"] for r in rows if r["qualified"]}
+
+
+def _selects_from_pairs(db: DuckDBBackend) -> set[tuple[str, str]]:
+    rows = db.run_read('SELECT src_key, dst_key FROM "SELECTS_FROM"', {})
+    return {(r["src_key"], r["dst_key"]) for r in rows}
+
+
+def test_non_table_create_objects_absent_real_lineage_present(db, tmp_path):
+    """SEQUENCE/STAGE/FILE FORMAT names absent; real INSERT...SELECT intact (AC-B3/B4)."""
+    (tmp_path / "fixture.sql").write_text(_FIXTURE_SQL)
+    Indexer().index_repo(tmp_path, dialect="snowflake", db=db, use_git=False)
+
+    nodes = _table_nodes(db)
+
+    # AC-B3: no SqlTable node for any non-table CREATE object.
+    for name in _PHANTOM_NAMES:
+        assert name not in nodes, f"phantom SqlTable node leaked for {name}: {sorted(nodes)}"
+
+    # AC-B3: no SELECTS_FROM edge touches a phantom name (as src or dst).
+    pairs = _selects_from_pairs(db)
+    for name in _PHANTOM_NAMES:
+        assert not any(name in pair for pair in pairs), (
+            f"phantom SELECTS_FROM edge touches {name}: {sorted(pairs)}"
+        )
+
+    # AC-B4 control: the real source/target survive. SELECTS_FROM is
+    # file -> source_table, so the real source must appear as a SELECTS_FROM dst.
+    assert "ba.real" in nodes, f"real source ba.real missing from nodes: {sorted(nodes)}"
+    assert "ba.t" in nodes, f"real target ba.t missing from nodes: {sorted(nodes)}"
+    assert any(dst == "ba.real" for _src, dst in pairs), (
+        f"real SELECTS_FROM edge into ba.real missing: {sorted(pairs)}"
+    )

sql_code_graph-1.35.1/tests/unit/test_phantom_non_table_create_source.py

@@ -0,0 +1,149 @@
+"""Non-table CREATE DDL must not emit its own object name as a source node.
+
+Guards the phantom-source-node bugfix (#161)
+([plan doc](plan/sprints/sprint_snowflake_lineage_patterns.md), PR-B).
+
+#159 fixed the *kind label* (non-table CREATE -> OTHER). The phantom SOURCE node
+persisted: for a `CREATE SEQUENCE ba.s` / `CREATE STAGE` / `CREATE FILE FORMAT`,
+`build_scope` returns None so source extraction fell to `_fallback_table_scan`,
+which scooped the object's OWN name (`ba.s`) into `QueryNode.sources` -> it then
+leaked into `ParsedFile.referenced_tables` (the unconditional
+`referenced_tables.extend(query_node.sources)` at ansi_parser.py:246 /
+snowflake_parser.py:784 / :944), creating a bogus SqlTable node + SELECTS_FROM
+edge in the graph.
+
+The fix is a single source-gate inside `AnsiParser._parse_statement`: when the
+statement is an `exp.Create` whose `kind` is not TABLE/VIEW, `sources = []`. The
+gate is keyed off the sqlglot AST (`stmt.kind`), so it is independent of the
+`_classify` path. CREATE TABLE/VIEW ... AS SELECT keep their kind and therefore
+keep their real sources (control tests below).
+
+Each assertion checks observable output (the `sources` list / `referenced_tables`
+list contents), not "no exception raised".
+"""
+
+from pathlib import Path
+
+import sqlglot
+
+from sqlcg.lineage.schema_resolver import SchemaResolver
+from sqlcg.parsers.ansi_parser import AnsiParser
+
+
+def _parse(sql: str) -> "tuple":
+    """Parse ``sql`` (snowflake dialect) and return (ParsedFile, first QueryNode)."""
+    parser = AnsiParser(SchemaResolver(dialect="snowflake"))
+    parsed = parser.parse_file(Path("t.sql"), sql)
+    first = parsed.statements[0] if parsed.statements else None
+    return parsed, first
+
+
+def _source_ids(node) -> list[str]:
+    return [s.full_id for s in node.sources]
+
+
+def _ref_ids(parsed) -> list[str]:
+    return [r.full_id for r in parsed.referenced_tables]
+
+
+class TestNonTableCreateEmitsNoPhantomSource:
+    """SEQUENCE / STAGE / FILE FORMAT names never appear as sources."""
+
+    def test_create_sequence_has_no_source(self):
+        """CREATE SEQUENCE: object name not scooped into sources (AC-B1)."""
+        parsed, node = _parse("CREATE SEQUENCE IF NOT EXISTS ba.wsdh_s1")
+        assert node is not None
+        assert node.sources == []
+        assert "ba.wsdh_s1" not in _ref_ids(parsed)
+        assert parsed.referenced_tables == []
+
+    def test_create_stage_has_no_source(self):
+        """CREATE STAGE: object name not scooped into sources (AC-B2)."""
+        parsed, node = _parse("CREATE STAGE ma.msstg_ingest URL='s3://x'")
+        assert node is not None
+        assert _source_ids(node) == []
+        assert "ma.msstg_ingest" not in _ref_ids(parsed)
+
+    def test_create_file_format_has_no_source(self):
+        """CREATE FILE FORMAT: object name not scooped into sources (AC-B2)."""
+        parsed, node = _parse("CREATE FILE FORMAT ma.msfmt_parquet TYPE=PARQUET")
+        assert node is not None
+        assert _source_ids(node) == []
+        assert "ma.msfmt_parquet" not in _ref_ids(parsed)
+
+    def test_create_schema_has_no_source(self):
+        """CREATE SCHEMA: object name not scooped into sources."""
+        parsed, node = _parse("CREATE SCHEMA da")
+        assert node is not None
+        assert _source_ids(node) == []
+
+
+class TestProcedurePhantomSuppressedButInnerDmlIntact:
+    """CREATE PROCEDURE top-level name is gated; spliced inner DML keeps lineage."""
+
+    def test_create_procedure_name_not_a_source(self):
+        """The procedure's own name is not emitted as a phantom source."""
+        sql = "CREATE PROCEDURE da.load_p() RETURNS STRING LANGUAGE SQL AS $$ SELECT 1 $$"
+        parsed, node = _parse(sql)
+        assert node is not None
+        assert "da.load_p" not in _source_ids(node)
+        assert "da.load_p" not in _ref_ids(parsed)
+
+    def test_spliced_inner_dml_lineage_intact(self):
+        """Inner DML recovered/spliced from EXECUTE IMMEDIATE still has real sources.
+
+        Real procedure lineage comes from the spliced inner statement (a separate
+        statement node), which the source-gate never touches. The gate only
+        suppresses the wrapper CREATE's own name. A recoverable inner CTAS keeps
+        its source (`da.real_src`) — proving gate edge-neutrality for the
+        inner-DML path.
+        """
+        from sqlcg.parsers.snowflake_parser import SnowflakeParser
+
+        sql = "EXECUTE IMMEDIATE 'CREATE TABLE da.sink AS SELECT a FROM da.real_src';"
+        parser = SnowflakeParser(SchemaResolver(dialect="snowflake"))
+        parsed = parser.parse_file(Path("p.sql"), sql)
+        refs = _ref_ids(parsed)
+        # The spliced inner CTAS's real source survives the gate.
+        assert "da.real_src" in refs
+        assert "da.sink" in [d.full_id for d in parsed.defined_tables]
+
+
+class TestTableAndViewCreateSourcesPreserved:
+    """Control: legitimate TABLE/VIEW CREATE keep their real sources."""
+
+    def test_ctas_keeps_real_source(self):
+        """CREATE TABLE t AS SELECT ... FROM real_src keeps the source (AC-B4)."""
+        parsed, node = _parse("CREATE TABLE da.t AS SELECT a FROM da.real_src")
+        assert node is not None
+        assert "da.real_src" in _source_ids(node)
+        assert "da.real_src" in _ref_ids(parsed)
+        # Target is not scooped as a source.
+        assert "da.t" not in _source_ids(node)
+
+    def test_create_view_keeps_real_source(self):
+        """CREATE VIEW v AS SELECT ... FROM real_src keeps the source (AC-B4)."""
+        parsed, node = _parse("CREATE OR REPLACE VIEW da.v AS SELECT a FROM da.real_src")
+        assert node is not None
+        assert "da.real_src" in _source_ids(node)
+        assert "da.real_src" in _ref_ids(parsed)
+
+
+class TestGateKeyedOnAst:
+    """The gate keys off the sqlglot AST kind, independent of _classify."""
+
+    def test_create_kinds_observed(self):
+        """Confirm the AST kinds the gate relies on (documentation guard)."""
+        kinds = {
+            sql: sqlglot.parse_one(sql, dialect="snowflake").kind
+            for sql in (
+                "CREATE SEQUENCE ba.s",
+                "CREATE STAGE ma.stg",
+                "CREATE FILE FORMAT ff TYPE=CSV",
+                "CREATE TABLE da.t AS SELECT a FROM da.s",
+                "CREATE OR REPLACE VIEW da.v AS SELECT a FROM da.s",
+            )
+        }
+        assert kinds["CREATE SEQUENCE ba.s"] == "SEQUENCE"
+        assert kinds["CREATE TABLE da.t AS SELECT a FROM da.s"] == "TABLE"
+        assert kinds["CREATE OR REPLACE VIEW da.v AS SELECT a FROM da.s"] == "VIEW"

{sql_code_graph-1.35.0 → sql_code_graph-1.35.1}/uv.lock

@@ -2844,7 +2844,7 @@ wheels = [
 
 [[package]]
 name = "sql-code-graph"
-version = "1.35.0"
+version = "1.35.1"
 source = { editable = "." }
 dependencies = [
     { name = "duckdb" },