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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-glider
-Version: 0.1.8
+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.8 → 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.8'
-__version_tuple__ = version_tuple = (0, 1, 8)
+__version__ = version = '0.1.9'
+__version_tuple__ = version_tuple = (0, 1, 9)
 
 __commit_id__ = commit_id = None

{sql_glider-0.1.8 → 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.8 → 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