sql-glider 0.1.7__tar.gz → 0.1.9__tar.gz

{sql_glider-0.1.7 → sql_glider-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-glider
-Version: 0.1.7
+Version: 0.1.9
 Summary: SQL Utility Toolkit for better understanding, use, and governance of your queries in a native environment.
 Project-URL: Homepage, https://github.com/rycowhi/sql-glider/
 Project-URL: Repository, https://github.com/rycowhi/sql-glider/

{sql_glider-0.1.7 → sql_glider-0.1.9}/src/sqlglider/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.7'
-__version_tuple__ = version_tuple = (0, 1, 7)
+__version__ = version = '0.1.9'
+__version_tuple__ = version_tuple = (0, 1, 9)
 
 __commit_id__ = commit_id = None

{sql_glider-0.1.7 → sql_glider-0.1.9}/src/sqlglider/graph/builder.py

@@ -117,8 +117,8 @@ class GraphBuilder:
                     edge_key = (item.source_name.lower(), item.output_name.lower())
                     if edge_key not in self._edge_set:
                         edge = GraphEdge(
-                            source_node=item.source_name,
-                            target_node=item.output_name,
+                            source_node=item.source_name.lower(),
+                            target_node=item.output_name.lower(),
                             file_path=file_path_str,
                             query_index=query_index,
                         )
@@ -285,7 +285,7 @@ class GraphBuilder:
             return self._node_index_map[key]
 
         node = GraphNode.from_identifier(
-            identifier=identifier,
+            identifier=key,
             file_path=file_path,
             query_index=query_index,
         )

{sql_glider-0.1.7 → sql_glider-0.1.9}/src/sqlglider/graph/serialization.py

@@ -61,15 +61,15 @@ def to_rustworkx(graph: LineageGraph) -> Tuple[rx.PyDiGraph, Dict[str, int]]:
     rx_graph: rx.PyDiGraph = rx.PyDiGraph()
     node_map: Dict[str, int] = {}
 
-    # Add nodes
+    # Add nodes (use lowercase keys for case-insensitive lookup)
     for node in graph.nodes:
         idx = rx_graph.add_node(node.model_dump())
-        node_map[node.identifier] = idx
+        node_map[node.identifier.lower()] = idx
 
-    # Add edges
+    # Add edges (use lowercase for lookup to match node keys)
     for edge in graph.edges:
-        source_idx = node_map.get(edge.source_node)
-        target_idx = node_map.get(edge.target_node)
+        source_idx = node_map.get(edge.source_node.lower())
+        target_idx = node_map.get(edge.target_node.lower())
         if source_idx is not None and target_idx is not None:
             rx_graph.add_edge(source_idx, target_idx, edge.model_dump())
 

{sql_glider-0.1.7 → sql_glider-0.1.9}/src/sqlglider/lineage/analyzer.py

@@ -615,6 +615,12 @@ class LineageAnalyzer:
             if isinstance(target, exp.Table):
                 return (self._get_qualified_table_name(target), ObjectType.UNKNOWN)
 
+        # CACHE TABLE
+        elif isinstance(self.expr, exp.Cache):
+            target = self.expr.this
+            if isinstance(target, exp.Table):
+                return (self._get_qualified_table_name(target), ObjectType.TABLE)
+
         # DELETE FROM table
         elif isinstance(self.expr, exp.Delete):
             target = self.expr.this
@@ -706,6 +712,10 @@ class LineageAnalyzer:
         elif isinstance(self.expr, exp.Drop):
             return table_node is self.expr.this
 
+        # For CACHE TABLE, the target is self.expr.this
+        elif isinstance(self.expr, exp.Cache):
+            return table_node is self.expr.this
+
         return False
 
     def _analyze_column_lineage_internal(
@@ -889,6 +899,7 @@ class LineageAnalyzer:
             "Drop": f"DROP {getattr(target_expr, 'kind', '')}".strip(),
             "Alter": "ALTER",
             "Truncate": "TRUNCATE",
+            "Cache": "CACHE TABLE",
             "Command": "COMMAND",
         }
 
@@ -943,6 +954,17 @@ class LineageAnalyzer:
                     ):
                         return (target_name, select_node)
 
+        # Check for CACHE TABLE AS SELECT
+        elif isinstance(self.expr, exp.Cache):
+            target = self.expr.this
+            if isinstance(target, exp.Table):
+                target_name = self._get_qualified_table_name(target)
+                select_node = self.expr.expression
+                if isinstance(
+                    select_node, (exp.Select, exp.Union, exp.Intersect, exp.Except)
+                ):
+                    return (target_name, select_node)
+
         # Check for MERGE statement
         elif isinstance(self.expr, exp.Merge):
             target = self.expr.this

{sql_glider-0.1.7 → sql_glider-0.1.9}/tests/sqlglider/graph/test_query.py

@@ -196,7 +196,7 @@ class TestGraphQuerierUpstream:
         # Query with different case
         result = querier.find_upstream("TARGET.COLUMN")
 
-        assert result.query_column == "Target.Column"  # Original case preserved
+        assert result.query_column == "target.column"  # Normalized to lowercase
         assert len(result) == 1
 
 
@@ -302,7 +302,7 @@ class TestGraphQuerierDownstream:
         # Query with different case
         result = querier.find_downstream("source.column")
 
-        assert result.query_column == "Source.Column"  # Original case preserved
+        assert result.query_column == "source.column"  # Normalized to lowercase
         assert len(result) == 1
 
 

{sql_glider-0.1.7 → sql_glider-0.1.9}/tests/sqlglider/lineage/test_analyzer.py

@@ -2820,3 +2820,89 @@ class TestSemiAntiJoinColumnResolution:
         analyzer_semi = LineageAnalyzer(sql_semi, dialect="spark")
         analyzer_semi.analyze_queries(level=AnalysisLevel.COLUMN)
         assert set(analyzer_semi._file_schema["v3"].keys()) == {"a"}
+
+
+class TestCacheTableStatements:
+    """Tests for Spark SQL CACHE TABLE statement support."""
+
+    def test_cache_table_as_select_column_lineage(self):
+        """CACHE TABLE t AS SELECT should produce lineage with t as target."""
+        sql = """
+        CACHE TABLE cached_customers AS
+        SELECT customer_id, customer_name FROM customers
+        """
+        analyzer = LineageAnalyzer(sql, dialect="spark")
+        results = analyzer.analyze_queries(level=AnalysisLevel.COLUMN)
+
+        assert len(results) == 1
+        output_names = [item.output_name for item in results[0].lineage_items]
+        assert any("cached_customers" in name for name in output_names)
+        assert any("customer_id" in name for name in output_names)
+        assert any("customer_name" in name for name in output_names)
+
+    def test_cache_table_as_select_table_extraction(self):
+        """CACHE TABLE t AS SELECT should show cached_orders as OUTPUT table."""
+        sql = """
+        CACHE TABLE cached_orders AS
+        SELECT order_id, total FROM orders
+        """
+        analyzer = LineageAnalyzer(sql, dialect="spark")
+        results = analyzer.analyze_tables()
+
+        assert len(results) == 1
+        tables_by_name = {t.name: t for t in results[0].tables}
+
+        assert "cached_orders" in tables_by_name
+        assert tables_by_name["cached_orders"].usage.value == "OUTPUT"
+        assert tables_by_name["cached_orders"].object_type.value == "TABLE"
+
+        assert "orders" in tables_by_name
+        assert tables_by_name["orders"].usage.value == "INPUT"
+
+    def test_cache_table_as_select_with_join(self):
+        """CACHE TABLE with a JOIN query should trace all sources."""
+        sql = """
+        CACHE TABLE summary AS
+        SELECT c.customer_id, o.total
+        FROM customers c
+        JOIN orders o ON c.id = o.customer_id
+        """
+        analyzer = LineageAnalyzer(sql, dialect="spark")
+        results = analyzer.analyze_tables()
+
+        assert len(results) == 1
+        tables_by_name = {t.name: t for t in results[0].tables}
+
+        assert "summary" in tables_by_name
+        assert tables_by_name["summary"].usage.value == "OUTPUT"
+        assert "customers" in tables_by_name
+        assert tables_by_name["customers"].usage.value == "INPUT"
+        assert "orders" in tables_by_name
+        assert tables_by_name["orders"].usage.value == "INPUT"
+
+    def test_bare_cache_table_is_skipped(self):
+        """CACHE TABLE t (without AS SELECT) should be skipped."""
+        sql = "CACHE TABLE my_table"
+        analyzer = LineageAnalyzer(sql, dialect="spark")
+        results = analyzer.analyze_queries(level=AnalysisLevel.COLUMN)
+
+        assert len(results) == 0
+        skipped = analyzer.skipped_queries
+        assert len(skipped) == 1
+        assert "CACHE" in skipped[0].statement_type
+
+    def test_cache_table_in_multi_query(self):
+        """CACHE TABLE should work alongside other statements in multi-query files."""
+        sql = """
+        SELECT id FROM users;
+        CACHE TABLE cached_orders AS SELECT order_id FROM orders;
+        DELETE FROM old_data;
+        """
+        analyzer = LineageAnalyzer(sql, dialect="spark")
+        results = analyzer.analyze_queries(level=AnalysisLevel.COLUMN)
+
+        # SELECT and CACHE TABLE should produce results; DELETE is skipped
+        assert len(results) == 2
+        skipped = analyzer.skipped_queries
+        assert len(skipped) == 1
+        assert "DELETE" in skipped[0].statement_type