sql-code-graph 1.4.0__py3-none-any.whl → 1.4.1__py3-none-any.whl

{sql_code_graph-1.4.0.dist-info → sql_code_graph-1.4.1.dist-info}/METADATA

@@ -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.dist-info → sql_code_graph-1.4.1.dist-info}/RECORD

@@ -1,9 +1,9 @@
-sqlcg/__init__.py,sha256=spIaM-bJwyRvB5fw8VYDKkrB5Lz7cKAgRuvBBgKYX3g,115
+sqlcg/__init__.py,sha256=Q9RK3IHj_JNrfASKHyNaH76PD2u74uMssIwE5Mi7F7Q,115
 sqlcg/__main__.py,sha256=1YoFLcqEgTwYq1J3TbUwpkdG0zeeLIf2fJvwWI-CLFU,109
 sqlcg/cli/__init__.py,sha256=W8fD0LpMq2xm_5WKGNMvJh2WBL1ho5E8hUeAqXQYT1g,28
 sqlcg/cli/main.py,sha256=WmdTjsOlz1ozi2Y3Aq4ezR_FCRl-Lc1YOKw3_d48dlY,1650
 sqlcg/cli/commands/__init__.py,sha256=oSHtr6VD-jNubOjuCQyZj2tBppjMEpQDh-IGQ8of9eA,30
-sqlcg/cli/commands/analyze.py,sha256=YG5N1iYG-ierDgAJ36mFpQ4BMf2yJ4YF-UV7Rx-bmYA,11793
+sqlcg/cli/commands/analyze.py,sha256=_aC5ML3w7YdLi7DL3TFS9OiCEIipuNZxWR6S4peTcn4,12154
 sqlcg/cli/commands/db.py,sha256=TMhPCHRWSo8YmlNnSxmGxrR0_1r3K4e0Bn8unZTkvU4,7248
 sqlcg/cli/commands/find.py,sha256=p5Vyyx-VBk8YDWYQN16UhECh7PIeMaEyCPEcUFcRFlM,2598
 sqlcg/cli/commands/gain.py,sha256=SJU1c51a7MgNbZItqQnaBfOWGnV5xpXQctbew5Dr9BE,9062
@@ -41,7 +41,7 @@ sqlcg/metrics/__init__.py,sha256=hLJ6wm4St8qqYwKh3o9QG7lcEt1BEYM31ccqO9tGpIg,133
 sqlcg/metrics/store.py,sha256=KuDtxvyAgug9_KtiSCpvgKM2VZM7VSaI3D11uMLjJJk,10604
 sqlcg/parsers/__init__.py,sha256=AamA8wBbDZV9_zEtZCI4Hyen5UAVKHmBwjTghTt2PZE,785
 sqlcg/parsers/ansi_parser.py,sha256=mGZvijMOMQ4i1BybpwU29a8jnIGViefhy9fxzkSpsRM,17193
-sqlcg/parsers/base.py,sha256=IiOkVsm6jz9-48RqDCXiW-UXAraNxQ4pKXvSA7aolnA,49907
+sqlcg/parsers/base.py,sha256=N6uqQWHO2lpzTIWgPqzewAXmij0ikZdNmNVJkIQ8Mr0,54889
 sqlcg/parsers/bigquery_parser.py,sha256=mOnWTfXB_Dp4JwFE1PVYOB6CDPf5nYE0Dea8kJCl9uQ,2827
 sqlcg/parsers/postgres_parser.py,sha256=lYfUpQY6j4Qm7ndXBtXbgPoGzYqYddWt5YeFnWKdA6I,946
 sqlcg/parsers/registry.py,sha256=LXy1F6rqQI6VdxpRvZg_tNpoEucW3mXZHYBMlMONbX4,1496
@@ -61,7 +61,7 @@ sqlcg/utils/__init__.py,sha256=--iqt5ThTXmT8Wz7da8hs3n0zDfYPl8P-z5OgRJ_77E,154
 sqlcg/utils/hashing.py,sha256=H25-sYfxHKb3_IERFnHyAIYNiXN470Oqo5sJT_D3YOA,438
 sqlcg/utils/ignore.py,sha256=wJjwa0mjnQ_xJExOUxk25y00g065XmmzJapqV3ifD5o,1151
 sqlcg/utils/logging.py,sha256=u0fCmYsLj9o81vawm3xZTHaw68GQYVm7JxG-gP81u8A,840
-sql_code_graph-1.4.0.dist-info/METADATA,sha256=rjzA7ons9zPtU1rsKtlhdx3z3qJUrVHL7tYfdg1HcrE,14085
-sql_code_graph-1.4.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-sql_code_graph-1.4.0.dist-info/entry_points.txt,sha256=Wfe49sVzV9p4eVFGo5RxcV-frr3HOP0yzzst8JBxQLQ,46
-sql_code_graph-1.4.0.dist-info/RECORD,,
+sql_code_graph-1.4.1.dist-info/METADATA,sha256=7psrSu1Vh3GiZ7PK7FED45QzazeUrHrltrRla4twAVQ,14085
+sql_code_graph-1.4.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+sql_code_graph-1.4.1.dist-info/entry_points.txt,sha256=Wfe49sVzV9p4eVFGo5RxcV-frr3HOP0yzzst8JBxQLQ,46
+sql_code_graph-1.4.1.dist-info/RECORD,,

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__"]

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:])

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.