sql-code-graph 1.4.0__tar.gz → 1.4.1__tar.gz

{sql_code_graph-1.4.0 → sql_code_graph-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-code-graph
-Version: 1.4.0
+Version: 1.4.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.4.0 → sql_code_graph-1.4.1}/pyproject.toml

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

{sql_code_graph-1.4.0 → sql_code_graph-1.4.1}/src/sqlcg/__init__.py

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

{sql_code_graph-1.4.0 → sql_code_graph-1.4.1}/src/sqlcg/cli/commands/analyze.py

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

{sql_code_graph-1.4.0 → sql_code_graph-1.4.1}/src/sqlcg/parsers/base.py

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

sql_code_graph-1.4.1/tests/integration/test_analyze_case_fold.py

@@ -0,0 +1,234 @@
+"""#50 — analyze upstream/downstream case-fold integration tests (PR-2).
+
+Confirmed live on the DWH (v1.4.0): ``analyze upstream "BA.WTFE_INKOOP_ORDER_IGDC.TA_HASH"``
+returned "No results" while the lowercase form returned the full upstream table.
+Root cause: ``analyze.py`` upstream/downstream and ``_bare_ref`` did not lowercase the
+``ref`` argument before querying — graph keys are lowercased at index time (C2 normalization).
+
+Fix (PR-2): ``ref = ref.lower()`` at the top of both command functions, plus a defensive
+``ref = ref.lower()`` inside ``_bare_ref``.
+
+These integration tests use a real DuckDB in-memory graph.  They assert on the
+**observable returned id sets** (not "no exception"), using a small fixture with a
+real upstream chain.
+
+Entry-point parity audit (recorded here per plan PR-2):
+  - CLI ``analyze.py`` upstream/downstream: fixed by this PR (were missing ``.lower()``).
+  - CLI ``analyze.py`` _bare_ref: defensive ``.lower()`` added by this PR.
+  - MCP ``tools.py``: already fully case-folded via ``_parse_column_ref`` (line ~323,
+    ``col_ref.lower()``) and direct ``.lower()`` calls at lines ~798, ~845, ~902, ~978,
+    ~1725.  No MCP changes required.
+  - CLI ``find.py``: already folds at lines 19 and 41.
+  - CLI ``analyze.py`` ``impact`` (table-level): out of #50's stated scope; uses table
+    names not column refs.  Flagged as a separate follow-up if needed.
+
+After this PR, CLI analyze upstream/downstream and MCP are parity-correct on case folding.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import pytest
+from typer.testing import CliRunner
+
+from sqlcg.cli.commands.analyze import _bare_ref
+from sqlcg.cli.main import app
+from sqlcg.core.duckdb_backend import DuckDBBackend
+from sqlcg.indexer.indexer import Indexer
+
+# ---------------------------------------------------------------------------
+# Fixture SQL corpus
+#
+# Simple 2-hop upstream chain:
+#   mart.fact_enriched.m  ←  staging.src_raw.val
+# Through a single CTE hop.
+# ---------------------------------------------------------------------------
+
+_DDL_SQL = """\
+CREATE TABLE mart.fact_enriched (m NUMBER, k VARCHAR);
+"""
+
+_ETL_SQL = """\
+INSERT INTO mart.fact_enriched (m, k)
+WITH raw AS (SELECT val AS m, key AS k FROM staging.src_raw)
+SELECT m, k FROM raw;
+"""
+
+runner = CliRunner()
+
+
+@pytest.fixture
+def db():
+    """Fresh in-memory DuckDB backend with schema initialised."""
+    backend = DuckDBBackend(":memory:")
+    backend.init_schema()
+    yield backend
+    backend.close()
+
+
+@pytest.fixture
+def indexed_db(db, tmp_path):
+    """Index the fixture corpus; return the backend."""
+    (tmp_path / "ddl.sql").write_text(_DDL_SQL)
+    (tmp_path / "etl.sql").write_text(_ETL_SQL)
+    Indexer().index_repo(tmp_path, dialect=None, db=db, use_git=False)
+    return db
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _run_upstream(db: DuckDBBackend, ref: str) -> list[dict]:
+    """Invoke analyze upstream via Typer, routing run_read_routed to the in-memory db.
+
+    Patches run_read_routed to call db.run_read directly, so we exercise the
+    real SQL against the indexed in-memory graph — while the command function's
+    ``ref = ref.lower()`` case-fold is in effect.
+    """
+    from sqlcg.cli.commands.analyze import _upstream_sql
+
+    def _route(sql: str, params: dict, db_path=None) -> list[dict]:
+        return db.run_read(sql, params)
+
+    with patch("sqlcg.cli.commands.analyze.run_read_routed", side_effect=_route):
+        with patch("sqlcg.server.noise_filter.NoiseFilter.from_config") as mock_nf:
+            nf = mock_nf.return_value
+            nf.is_noise.return_value = False
+            runner.invoke(app, ["analyze", "upstream", ref])
+
+    # Return raw rows from the DB using the lowercased ref (the command path result).
+    query = _upstream_sql(5, include_intermediate=False)
+    return db.run_read(query, {"ref": ref.lower()})
+
+
+def _run_downstream(db: DuckDBBackend, ref: str) -> list[dict]:
+    """Invoke analyze downstream via Typer, routing run_read_routed to the in-memory db."""
+    from sqlcg.cli.commands.analyze import _downstream_sql
+
+    def _route(sql: str, params: dict, db_path=None) -> list[dict]:
+        return db.run_read(sql, params)
+
+    with patch("sqlcg.cli.commands.analyze.run_read_routed", side_effect=_route):
+        with patch("sqlcg.server.noise_filter.NoiseFilter.from_config") as mock_nf:
+            nf = mock_nf.return_value
+            nf.is_noise.return_value = False
+            runner.invoke(app, ["analyze", "downstream", ref])
+
+    query = _downstream_sql(5, include_intermediate=False)
+    return db.run_read(query, {"ref": ref.lower()})
+
+
+# ---------------------------------------------------------------------------
+# Tests — upstream case-fold (real graph, observable ids)
+# ---------------------------------------------------------------------------
+
+
+def test_uppercase_upstream_anchor_returns_same_ids_as_lowercase(indexed_db):
+    """UPPERCASE anchor returns the identical non-empty upstream id set as lowercase.
+
+    This is the confirmed DWH regression: uppercase ref passed to run_read_routed
+    found nothing because graph keys are stored lowercase.  After the fix
+    (ref = ref.lower() at top of upstream()), the fold happens before the query.
+
+    We test observably: both forms produce the same non-empty id set.
+    """
+    lowercase_rows = _run_upstream(indexed_db, "mart.fact_enriched.m")
+    uppercase_rows = _run_upstream(indexed_db, "MART.FACT_ENRICHED.M")
+
+    lowercase_ids = {r["id"] for r in lowercase_rows}
+    uppercase_ids = {r["id"] for r in uppercase_rows}
+
+    assert lowercase_ids, (
+        "Baseline lowercase upstream returned no results — fixture or indexer issue."
+    )
+    assert uppercase_ids, (
+        "UPPERCASE upstream returned no results while lowercase returned results — "
+        "the case-fold fix (ref = ref.lower()) is missing from analyze.upstream()."
+    )
+    assert uppercase_ids == lowercase_ids, (
+        f"UPPERCASE and lowercase upstream returned different id sets.\n"
+        f"  lowercase: {sorted(lowercase_ids)}\n"
+        f"  uppercase: {sorted(uppercase_ids)}"
+    )
+    # Both must contain the physical source column from the fixture.
+    assert "staging.src_raw.val" in lowercase_ids, (
+        f"Expected staging.src_raw.val in upstream ids.\nGot: {sorted(lowercase_ids)}"
+    )
+
+
+def test_mixedcase_upstream_anchor_returns_same_ids_as_lowercase(indexed_db):
+    """Mixed-case anchor (e.g. 'Mart.Fact_Enriched.M') returns the same upstream ids."""
+    lowercase_rows = _run_upstream(indexed_db, "mart.fact_enriched.m")
+    mixedcase_rows = _run_upstream(indexed_db, "Mart.Fact_Enriched.M")
+
+    lowercase_ids = {r["id"] for r in lowercase_rows}
+    mixedcase_ids = {r["id"] for r in mixedcase_rows}
+
+    assert mixedcase_ids, "Mixed-case upstream returned no results — the case-fold fix is missing."
+    assert mixedcase_ids == lowercase_ids, (
+        f"Mixed-case and lowercase upstream returned different id sets.\n"
+        f"  lowercase: {sorted(lowercase_ids)}\n"
+        f"  mixed-case: {sorted(mixedcase_ids)}"
+    )
+
+
+# ---------------------------------------------------------------------------
+# Tests — downstream case-fold (real graph, observable ids)
+# ---------------------------------------------------------------------------
+
+
+def test_uppercase_downstream_anchor_returns_same_ids_as_lowercase(indexed_db):
+    """UPPERCASE anchor returns the identical non-empty downstream id set as lowercase."""
+    lowercase_rows = _run_downstream(indexed_db, "staging.src_raw.val")
+    uppercase_rows = _run_downstream(indexed_db, "STAGING.SRC_RAW.VAL")
+
+    lowercase_ids = {r["id"] for r in lowercase_rows}
+    uppercase_ids = {r["id"] for r in uppercase_rows}
+
+    assert lowercase_ids, (
+        "Baseline lowercase downstream returned no results — fixture or indexer issue."
+    )
+    assert uppercase_ids, (
+        "UPPERCASE downstream returned no results while lowercase returned results — "
+        "the case-fold fix (ref = ref.lower()) is missing from analyze.downstream()."
+    )
+    assert uppercase_ids == lowercase_ids, (
+        f"UPPERCASE and lowercase downstream returned different id sets.\n"
+        f"  lowercase: {sorted(lowercase_ids)}\n"
+        f"  uppercase: {sorted(uppercase_ids)}"
+    )
+    assert "mart.fact_enriched.m" in lowercase_ids, (
+        f"Expected mart.fact_enriched.m in downstream ids.\nGot: {sorted(lowercase_ids)}"
+    )
+
+
+# ---------------------------------------------------------------------------
+# Tests — _bare_ref defensive lower
+# ---------------------------------------------------------------------------
+
+
+def test_bare_ref_lowercases_3part_uppercase_ref():
+    """_bare_ref applied to a 3-part UPPERCASE ref returns a lowercase bare ref.
+
+    The defensive ``ref = ref.lower()`` inside ``_bare_ref`` ensures the helper is
+    safe to call independently of the caller's folding, matching graph key casing.
+    """
+    result = _bare_ref("BA.WTFE_INKOOP_ORDER_IGDC.TA_HASH")
+    assert result == "wtfe_inkoop_order_igdc.ta_hash", (
+        f"_bare_ref did not lowercase: got '{result}'"
+    )
+
+
+def test_bare_ref_lowercases_mixedcase_ref():
+    """_bare_ref on a mixed-case 3-part ref returns a lowercase bare ref."""
+    result = _bare_ref("Mart.Fact_Enriched.M")
+    assert result == "fact_enriched.m", f"_bare_ref did not lowercase: got '{result}'"
+
+
+def test_bare_ref_already_lowercase_is_unchanged():
+    """_bare_ref on an already-lowercase ref is idempotent."""
+    result = _bare_ref("mart.fact_enriched.m")
+    assert result == "fact_enriched.m"