sql-code-graph 1.34.1__tar.gz → 1.34.2__tar.gz

{sql_code_graph-1.34.1 → sql_code_graph-1.34.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-code-graph
-Version: 1.34.1
+Version: 1.34.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.34.2/plan/metrics/createkind_dwh_after.json

@@ -0,0 +1,31 @@
+{"total_calls": 1231, "last_7d_calls": 1231, "index_runs": 5, "feedback_tp": 0, 
+"feedback_total": 0, "top_tools": [{"name": "execute_sql", "count": 412}, 
+{"name": "trace_column_lineage", "count": 326}, {"name": 
+"list_dialects_and_repos", "count": 106}], "execute_sql_ratio": 0.33, 
+"parse_quality": {"sqlglot": 5166, "scripting": 20, "dynamic_sql": 3}, 
+"coverage": {"catalogued_tables": 5796, "total_tables": 6581, "good_edges": 
+51326, "total_edges": 59474, "phantom_edges": 12241, "blindspot_tables": 628, 
+"good_edges_strict": 46495, "edge_health_strict_pct": 78.18, 
+"good_edges_scoped": 36842, "total_edges_scoped": 37619, 
+"edge_health_scoped_pct": 97.93, "phantom_confirmed": 11701, 
+"phantom_contradicted": 352, "phantom_unverified": 188, "top_blindspot_tables": 
+[{"table": "ia_analytics.ba_wtfa_artikel_formule_dagomzet", "bad_edges": 217}, 
+{"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}], 
+"blindspot_tables_for_80pct": 15, "files_indexed": 1335, "indexed_sha": 
+"fdf1b551a34601a6cf3ce1c8b9f76e27ce2753e6", "db_path": "/tmp/ckm_after.duckdb", 
+"index_timestamp": 1781457191.07209, "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": 1040, "total_write_queries": 2323, 
+"cte_key_collisions": 0, "rescuable_unqualified_edges": 125, 
+"info_schema_has_column_rows": 110257, "cte_source_gap_writes": 0, 
+"resolvable_write_col_edges": 35759, "transitive_col_edges": 4168, 
+"qualify_failed_statements": 9, "tool_version_stale": false, 
+"indexed_tool_version": "1.34.3", "running_tool_version": "1.34.3"}}

sql_code_graph-1.34.2/plan/metrics/createkind_dwh_before.json

@@ -0,0 +1,31 @@
+{"total_calls": 1231, "last_7d_calls": 1231, "index_runs": 5, "feedback_tp": 0, 
+"feedback_total": 0, "top_tools": [{"name": "execute_sql", "count": 412}, 
+{"name": "trace_column_lineage", "count": 326}, {"name": 
+"list_dialects_and_repos", "count": 106}], "execute_sql_ratio": 0.33, 
+"parse_quality": {"sqlglot": 5162, "scripting": 20, "dynamic_sql": 3}, 
+"coverage": {"catalogued_tables": 5796, "total_tables": 6572, "good_edges": 
+51235, "total_edges": 59068, "phantom_edges": 12241, "blindspot_tables": 619, 
+"good_edges_strict": 46399, "edge_health_strict_pct": 78.55, 
+"good_edges_scoped": 36748, "total_edges_scoped": 37524, 
+"edge_health_scoped_pct": 97.93, "phantom_confirmed": 11701, 
+"phantom_contradicted": 352, "phantom_unverified": 188, "top_blindspot_tables": 
+[{"table": "ia_analytics.ba_wtfa_artikel_formule_dagomzet", "bad_edges": 216}, 
+{"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}], 
+"blindspot_tables_for_80pct": 15, "files_indexed": 1335, "indexed_sha": 
+"fdf1b551a34601a6cf3ce1c8b9f76e27ce2753e6", "db_path": "/tmp/ckm_before.duckdb",
+"index_timestamp": 1781456971.4233296, "degraded_parse_total": 5185, 
+"degraded_parse_queries": 20, "degraded_parse_by_dir": {"etl": {"degraded": 1, 
+"total": 2772}, "ddl": {"degraded": 19, "total": 2413}}, 
+"zero_edge_write_queries": 1069, "total_write_queries": 2351, 
+"cte_key_collisions": 0, "rescuable_unqualified_edges": 125, 
+"info_schema_has_column_rows": 110257, "cte_source_gap_writes": 0, 
+"resolvable_write_col_edges": 35351, "transitive_col_edges": 4174, 
+"qualify_failed_statements": 9, "tool_version_stale": false, 
+"indexed_tool_version": "1.34.1", "running_tool_version": "1.34.1"}}

{sql_code_graph-1.34.1 → sql_code_graph-1.34.2}/pyproject.toml

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

{sql_code_graph-1.34.1 → sql_code_graph-1.34.2}/src/sqlcg/__init__.py

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

{sql_code_graph-1.34.1 → sql_code_graph-1.34.2}/src/sqlcg/parsers/base.py

@@ -591,7 +591,8 @@ class SqlParser(ABC):
                     case "PROCEDURE" | "FUNCTION":
                         return QueryKind.CREATE_PROC
                     case _:
-                        return QueryKind.CREATE_TABLE  # Default to table
+                        # non-table CREATE (sequence/stage/file format/schema/index/etc.)
+                        return QueryKind.OTHER
             case exp.Merge():
                 return QueryKind.MERGE
             case _:

sql_code_graph-1.34.2/tests/integration/test_non_table_create_coverage_no_regression.py

@@ -0,0 +1,88 @@
+"""Coverage no-regression: non-table CREATE DDL is excluded from write-kind metrics.
+
+Pins blast-radius item #7 of the create-kind mislabel bugfix
+([plan doc](plan/sprints/bugfix_create_kind_mislabel.md), AC4).
+
+``_WRITE_KINDS = ("INSERT", "MERGE", "CREATE_TABLE", "UPDATE")`` drives
+``total_write_queries`` and ``zero_edge_write_queries``. Before the fix a
+``CREATE SEQUENCE`` was stored as ``CREATE_TABLE`` and so inflated both counters
+(it carries no COLUMN_LINEAGE, so it counted as a "zero-edge write" — a false
+unresolved-write gap). After the fix it classifies as ``OTHER`` and drops out of
+the write population. This is an honest-accounting correction, not a regression.
+
+Observable oracle: ``collect_coverage`` routed to the in-memory graph returns the
+write counts that exclude the sequence; an independent kind census on the same
+graph confirms the sequence is stored as ``OTHER``.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import pytest
+
+from sqlcg.cli.coverage import collect_coverage
+from sqlcg.core.duckdb_backend import DuckDBBackend
+from sqlcg.indexer.indexer import Indexer
+
+
+@pytest.fixture
+def indexed_db(tmp_path):
+    """Index a repo with one resolvable INSERT, one CREATE TABLE, one CREATE SEQUENCE.
+
+    Expected write population (kind IN _WRITE_KINDS):
+      * ba.src — CREATE TABLE (zero COLUMN_LINEAGE → a zero-edge write)
+      * ba.dst — INSERT … SELECT (has COLUMN_LINEAGE)
+    The CREATE SEQUENCE classifies as OTHER → NOT in the write population.
+    """
+    db = DuckDBBackend(":memory:")
+    db.init_schema()
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    (repo / "src.sql").write_text("CREATE TABLE ba.src (a INT);\n")
+    (repo / "ins.sql").write_text("INSERT INTO ba.dst SELECT a FROM ba.src;\n")
+    (repo / "seq.sql").write_text("CREATE SEQUENCE ba.s START 1;\n")
+    Indexer().index_repo(repo, dialect="snowflake", db=db, use_git=False)
+    yield db
+    db.close()
+
+
+def _collect(db: DuckDBBackend):
+    def _routed(query: str, params: dict):
+        return db.run_read(query, params)
+
+    with patch("sqlcg.cli.coverage.run_read_routed", side_effect=_routed):
+        return collect_coverage()
+
+
+def test_sequence_excluded_from_total_write_queries(indexed_db):
+    """total_write_queries counts only INSERT + CREATE TABLE, not the CREATE SEQUENCE."""
+    stats = _collect(indexed_db)
+    assert stats is not None
+    assert stats.total_write_queries == 2, (
+        "total_write_queries must count only the INSERT and the CREATE TABLE "
+        f"(the CREATE SEQUENCE is OTHER, excluded); got {stats.total_write_queries}. "
+        "A value of 3 means the sequence was mislabeled CREATE_TABLE again."
+    )
+
+
+def test_sequence_does_not_inflate_zero_edge_write_queries(indexed_db):
+    """zero_edge_write_queries reflects only the genuine zero-edge CREATE TABLE.
+
+    The CREATE SEQUENCE has zero COLUMN_LINEAGE; before the fix it would have
+    counted here as a false unresolved-write. Expected = 1 (the CREATE TABLE
+    'ba.src' DDL with no SELECT body), not 2.
+    """
+    stats = _collect(indexed_db)
+    assert stats is not None
+    assert stats.zero_edge_write_queries == 1, (
+        "zero_edge_write_queries must be 1 (the CREATE TABLE DDL only); "
+        f"got {stats.zero_edge_write_queries}. A value of 2 means the sequence "
+        "was counted as a zero-edge write (the inflation this fix removes)."
+    )
+
+
+def test_sequence_stored_as_other_kind(indexed_db):
+    """Independent oracle: the sequence statement is stored as kind=OTHER."""
+    rows = indexed_db.run_read('SELECT kind FROM "SqlQuery" WHERE id LIKE ?', {"id": "%seq.sql:0"})
+    assert rows and rows[0]["kind"] == "OTHER", f"sequence must be stored as OTHER; got {rows}"

sql_code_graph-1.34.2/tests/integration/test_non_table_create_kind_in_graph.py

@@ -0,0 +1,148 @@
+"""Integration test: non-table CREATE DDL is stored as SqlQuery.kind='OTHER'.
+
+End-to-end (parser → indexer → DuckDB) guard for the create-kind mislabel
+bugfix ([plan doc](plan/sprints/bugfix_create_kind_mislabel.md)).
+
+Scope (RESCOPED, kind-only — plan §Scope):
+  * AC1/AC2 — a fixture with CREATE SEQUENCE / STAGE plus real CREATE TABLE /
+    CTAS controls stores ``SqlQuery.kind = OTHER`` for the non-table DDL and
+    ``CREATE_TABLE`` for the genuine tables.
+  * 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.
+"""
+
+import pytest
+
+from sqlcg.core.duckdb_backend import DuckDBBackend
+from sqlcg.indexer.indexer import Indexer
+
+
+@pytest.fixture
+def db():
+    backend = DuckDBBackend(":memory:")
+    backend.init_schema()
+    yield backend
+    backend.close()
+
+
+def _kind_of_query(db: DuckDBBackend, id_suffix: str) -> str | None:
+    """Return SqlQuery.kind for the statement whose id ends with ``id_suffix``."""
+    rows = db.run_read(
+        'SELECT id, kind FROM "SqlQuery" WHERE id LIKE ?',
+        {"id": f"%{id_suffix}"},
+    )
+    return rows[0]["kind"] if rows else None
+
+
+@pytest.fixture
+def indexed(db, tmp_path):
+    """Index a repo with non-table CREATEs (SEQUENCE/STAGE) + table controls.
+
+    On the Snowflake path a ``CREATE SEQUENCE ba.s`` parses with target=None and
+    its name ``ba.s`` enters ``sources`` → a ``SELECTS_FROM`` edge to ``ba.s`` and
+    a phantom ``SqlTable`` source node (out of scope, see module docstring).
+    """
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    (repo / "seq.sql").write_text("CREATE SEQUENCE ba.s START 1;\n")
+    (repo / "stg.sql").write_text("CREATE STAGE ba.stg;\n")
+    (repo / "tbl.sql").write_text("CREATE TABLE ba.t (a INT);\n")
+    (repo / "ctas.sql").write_text("CREATE TABLE ba.t2 AS SELECT a FROM ba.t;\n")
+    Indexer().index_repo(repo, dialect="snowflake", db=db, use_git=False)
+    return repo
+
+
+def test_create_sequence_stored_as_other(indexed, db):
+    """AC1: CREATE SEQUENCE is stored as SqlQuery.kind='OTHER' (not CREATE_TABLE)."""
+    assert _kind_of_query(db, "seq.sql:0") == "OTHER", (
+        "CREATE SEQUENCE must store kind=OTHER after the catch-all flip; "
+        "before the fix it was mislabeled CREATE_TABLE."
+    )
+
+
+def test_create_stage_stored_as_other(indexed, db):
+    """AC1: CREATE STAGE is stored as SqlQuery.kind='OTHER'."""
+    assert _kind_of_query(db, "stg.sql:0") == "OTHER", (
+        "CREATE STAGE must store kind=OTHER, not CREATE_TABLE."
+    )
+
+
+def test_real_create_table_still_create_table(indexed, db):
+    """AC2: a genuine CREATE TABLE control still stores kind='CREATE_TABLE'."""
+    assert _kind_of_query(db, "tbl.sql:0") == "CREATE_TABLE", (
+        "Plain CREATE TABLE must remain CREATE_TABLE (no regression on real tables)."
+    )
+
+
+def test_ctas_still_create_table(indexed, db):
+    """AC2: CTAS (CREATE TABLE AS SELECT) control still stores kind='CREATE_TABLE'."""
+    assert _kind_of_query(db, "ctas.sql:0") == "CREATE_TABLE", (
+        "CTAS has Create.kind=='TABLE' and must remain CREATE_TABLE."
+    )
+
+
+def test_sequence_produces_selects_from_edge(indexed, db):
+    """The sequence statement carries a SELECTS_FROM edge to its name node.
+
+    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).
+    """
+    rows = db.run_read(
+        'SELECT q.id AS id, q.kind AS kind FROM "SqlQuery" q '
+        'JOIN "SELECTS_FROM" sf ON sf.src_key = q.id '
+        "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}"
+    )
+
+
+def test_analyze_impact_renders_sequence_as_other(indexed, db, monkeypatch):
+    """AC3: ``analyze impact ba.s`` renders the producing statement kind=OTHER.
+
+    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).
+    """
+    # Direct query (analyze.py:317 shape) — observable kind on the producer row.
+    results = db.run_read(
+        "SELECT DISTINCT q.id AS id, q.kind AS kind, q.target_table AS target"
+        ' FROM "SqlTable" t'
+        ' JOIN "SELECTS_FROM" sf ON sf.dst_key = t.qualified'
+        ' JOIN "SqlQuery" q ON q.id = sf.src_key'
+        " 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}"
+    )
+
+    # CLI render path: kind=OTHER appears, CREATE_TABLE does not.
+    from typer.testing import CliRunner
+
+    from sqlcg.cli.commands.analyze import app
+
+    def _route_to_db(query, params):
+        return db.run_read(query, params)
+
+    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.34.2/tests/unit/test_classify_non_table_create_kind.py

@@ -0,0 +1,88 @@
+"""Unit tests for ``SqlParser._classify`` on non-table ``CREATE`` DDL.
+
+Guards the create-kind mislabel bugfix
+([plan doc](plan/sprints/bugfix_create_kind_mislabel.md)).
+
+Before the fix the ``exp.Create`` catch-all returned ``CREATE_TABLE`` for every
+``Create.kind`` it did not explicitly handle, so ``CREATE SEQUENCE`` /
+``CREATE STAGE`` / ``CREATE FILE FORMAT`` (and ``SCHEMA`` / ``INDEX``) were all
+stored as ``CREATE_TABLE``. The catch-all now returns ``OTHER``.
+
+Safety property under test (AC2): every statement that is *genuinely* a table —
+plain ``CREATE TABLE``, ``TRANSIENT TABLE``, ``OR REPLACE TABLE`` and CTAS — has
+``Create.kind == "TABLE"`` and so hits the explicit arm; the flip to ``OTHER``
+cannot reclassify a real table.
+
+Each assertion checks the observable returned kind string, not "no exception".
+"""
+
+import sqlglot
+
+from sqlcg.lineage.schema_resolver import SchemaResolver
+from sqlcg.parsers.ansi_parser import AnsiParser
+
+
+def _classify(sql: str) -> str:
+    """Parse ``sql`` (snowflake dialect) and return the stored query kind."""
+    parser = AnsiParser(SchemaResolver(dialect="snowflake"))
+    node = sqlglot.parse_one(sql, dialect="snowflake")
+    return parser._classify(node)
+
+
+class TestNonTableCreateClassifiesAsOther:
+    """Non-table CREATE DDL must classify as OTHER, not CREATE_TABLE."""
+
+    def test_create_sequence_classifies_as_other(self):
+        """CREATE SEQUENCE (Create.kind == 'SEQUENCE') is OTHER."""
+        assert _classify("CREATE SEQUENCE ba.s START 1") == "OTHER"
+
+    def test_create_stage_classifies_as_other(self):
+        """CREATE STAGE (Create.kind == 'STAGE') is OTHER."""
+        assert _classify("CREATE STAGE ma.stg") == "OTHER"
+
+    def test_create_file_format_classifies_as_other(self):
+        """CREATE FILE FORMAT (Create.kind == 'FILE FORMAT') is OTHER."""
+        assert _classify("CREATE FILE FORMAT ff TYPE=CSV") == "OTHER"
+
+    def test_create_schema_classifies_as_other(self):
+        """CREATE SCHEMA (Create.kind == 'SCHEMA') is OTHER."""
+        assert _classify("CREATE SCHEMA s") == "OTHER"
+
+    def test_create_index_classifies_as_other(self):
+        """CREATE INDEX (Create.kind == 'INDEX') is OTHER."""
+        assert _classify("CREATE INDEX i ON t(a)") == "OTHER"
+
+
+class TestRealTableCreateStillClassifiesAsCreateTable:
+    """Control: every genuine table CREATE keeps CREATE_TABLE (safety property)."""
+
+    def test_plain_create_table_classifies_as_create_table(self):
+        """Plain CREATE TABLE keeps CREATE_TABLE."""
+        assert _classify("CREATE TABLE t (a INT)") == "CREATE_TABLE"
+
+    def test_transient_table_classifies_as_create_table(self):
+        """CREATE TRANSIENT TABLE has Create.kind == 'TABLE' → CREATE_TABLE."""
+        assert _classify("CREATE TRANSIENT TABLE t (a INT)") == "CREATE_TABLE"
+
+    def test_or_replace_table_classifies_as_create_table(self):
+        """CREATE OR REPLACE TABLE has Create.kind == 'TABLE' → CREATE_TABLE."""
+        assert _classify("CREATE OR REPLACE TABLE t (a INT)") == "CREATE_TABLE"
+
+    def test_ctas_classifies_as_create_table(self):
+        """CTAS (CREATE TABLE AS SELECT) has Create.kind == 'TABLE' → CREATE_TABLE."""
+        assert _classify("CREATE TABLE t AS SELECT a FROM s") == "CREATE_TABLE"
+
+
+class TestViewAndProcUnaffected:
+    """VIEW / PROCEDURE explicit arms are unchanged by the catch-all flip."""
+
+    def test_create_view_classifies_as_create_view(self):
+        """CREATE VIEW keeps CREATE_VIEW."""
+        assert _classify("CREATE VIEW v AS SELECT a FROM s") == "CREATE_VIEW"
+
+    def test_create_procedure_classifies_as_create_proc(self):
+        """CREATE PROCEDURE keeps CREATE_PROC."""
+        assert (
+            _classify("CREATE PROCEDURE p() RETURNS INT AS $$ BEGIN RETURN 1; END $$")
+            == "CREATE_PROC"
+        )

{sql_code_graph-1.34.1 → sql_code_graph-1.34.2}/uv.lock

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