sql-glider 0.1.18__tar.gz → 0.1.19__tar.gz

{sql_glider-0.1.18 → sql_glider-0.1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-glider
-Version: 0.1.18
+Version: 0.1.19
 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.18 → sql_glider-0.1.19}/src/sqlglider/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.18'
-__version_tuple__ = version_tuple = (0, 1, 18)
+__version__ = version = '0.1.19'
+__version_tuple__ = version_tuple = (0, 1, 19)
 
 __commit_id__ = commit_id = None

{sql_glider-0.1.18 → sql_glider-0.1.19}/src/sqlglider/lineage/analyzer.py

@@ -1480,7 +1480,7 @@ class LineageAnalyzer:
 
     def _extract_schema_from_statement(self, expr: exp.Expression) -> None:
         """
-        Extract column definitions from CREATE VIEW/TABLE AS SELECT statements.
+        Extract column definitions from CREATE VIEW/TABLE AS SELECT and CACHE TABLE statements.
 
         This method builds up file-scoped schema context as statements are processed,
         enabling SQLGlot to correctly expand SELECT * and trace cross-statement references.
@@ -1488,29 +1488,39 @@ class LineageAnalyzer:
         Args:
             expr: The SQL expression to extract schema from
         """
-        # Only handle CREATE VIEW or CREATE TABLE (AS SELECT)
-        if not isinstance(expr, exp.Create):
-            return
-        if expr.kind not in ("VIEW", "TABLE"):
-            return
+        target_name: str | None = None
+        select_node: exp.Expression | None = None
 
-        # Get target table/view name
-        target = expr.this
-        if isinstance(target, exp.Schema):
-            target = target.this
-        if not isinstance(target, exp.Table):
-            return
+        if isinstance(expr, exp.Create):
+            if expr.kind not in ("VIEW", "TABLE"):
+                return
+
+            target = expr.this
+            if isinstance(target, exp.Schema):
+                target = target.this
+            if not isinstance(target, exp.Table):
+                return
 
-        target_name = self._get_qualified_table_name(target)
+            target_name = self._get_qualified_table_name(target)
+            select_node = expr.expression
 
-        # Get the SELECT node from the CREATE statement
-        select_node = expr.expression
-        if select_node is None:
+            # Handle Subquery wrapper (e.g., CREATE VIEW AS (SELECT ...))
+            if isinstance(select_node, exp.Subquery):
+                select_node = select_node.this
+
+        elif isinstance(expr, exp.Cache):
+            target = expr.this
+            if not isinstance(target, exp.Table):
+                return
+
+            target_name = self._get_qualified_table_name(target)
+            select_node = expr.expression
+
+        else:
             return
 
-        # Handle Subquery wrapper (e.g., CREATE VIEW AS (SELECT ...))
-        if isinstance(select_node, exp.Subquery):
-            select_node = select_node.this
+        if target_name is None or select_node is None:
+            return
 
         if not isinstance(
             select_node, (exp.Select, exp.Union, exp.Intersect, exp.Except)

{sql_glider-0.1.18 → sql_glider-0.1.19}/tests/sqlglider/lineage/test_analyzer.py

@@ -2949,6 +2949,62 @@ class TestCacheTableStatements:
         assert len(skipped) == 1
         assert "DELETE" in skipped[0].statement_type
 
+    def test_cache_table_star_resolution_in_subsequent_query(self):
+        """SELECT * FROM a cached table should resolve columns from the CACHE statement."""
+        sql = """
+        CACHE TABLE cached_orders AS SELECT customer_id, order_total FROM orders;
+        SELECT * FROM cached_orders;
+        """
+        analyzer = LineageAnalyzer(sql, dialect="spark")
+        results = analyzer.analyze_queries(level=AnalysisLevel.COLUMN)
+
+        assert len(results) == 2
+        # Second query should have resolved the star
+        star_result = results[1]
+        output_names = sorted(item.output_name for item in star_result.lineage_items)
+        output_names = sorted(item.output_name for item in star_result.lineage_items)
+        assert output_names == ["customer_id", "order_total"]
+
+    def test_cache_table_qualified_star_resolution(self):
+        """table.* on a cached table should resolve columns."""
+        sql = """
+        CACHE TABLE cached_orders AS SELECT customer_id, order_total FROM orders;
+        SELECT cached_orders.* FROM cached_orders;
+        """
+        analyzer = LineageAnalyzer(sql, dialect="spark")
+        results = analyzer.analyze_queries(level=AnalysisLevel.COLUMN)
+
+        assert len(results) == 2
+        star_result = results[1]
+        output_names = sorted(item.output_name for item in star_result.lineage_items)
+        assert output_names == ["customer_id", "order_total"]
+
+    def test_cache_lazy_table_star_resolution(self):
+        """CACHE LAZY TABLE should also register schema for star resolution."""
+        sql = """
+        CACHE LAZY TABLE cached_users AS SELECT id, name, email FROM users;
+        SELECT * FROM cached_users;
+        """
+        analyzer = LineageAnalyzer(sql, dialect="spark")
+        results = analyzer.analyze_queries(level=AnalysisLevel.COLUMN)
+
+        assert len(results) == 2
+        star_result = results[1]
+        output_names = sorted(item.output_name for item in star_result.lineage_items)
+        assert output_names == ["email", "id", "name"]
+
+    def test_cache_table_schema_registered(self):
+        """Cached table schema should be registered for downstream star resolution."""
+        sql = """
+        CACHE TABLE cached_orders AS SELECT customer_id, order_total FROM orders;
+        SELECT * FROM cached_orders;
+        """
+        analyzer = LineageAnalyzer(sql, dialect="spark")
+        schema = analyzer.extract_schema_only()
+        assert "cached_orders" in schema
+        assert "customer_id" in schema["cached_orders"]
+        assert "order_total" in schema["cached_orders"]
+
 
 class TestNoStar:
     """Tests for the --no-star flag that fails on unresolvable SELECT *."""