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

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

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

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

@@ -1177,7 +1177,7 @@ class LineageAnalyzer:
         if table.db:
             parts.append(table.db)
         parts.append(table.name)
-        return ".".join(parts)
+        return ".".join(parts).lower()
 
     def _resolve_table_reference(self, ref: str, select_node: exp.Select) -> str:
         """
@@ -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)
@@ -1522,7 +1532,7 @@ class LineageAnalyzer:
 
         if columns:
             # Store with UNKNOWN type - SQLGlot only needs column names for expansion
-            self._file_schema[target_name] = {col: "UNKNOWN" for col in columns}
+            self._file_schema[target_name] = {col.lower(): "UNKNOWN" for col in columns}
 
     def _extract_schema_from_dql(self, expr: exp.Expression) -> None:
         """Infer table schemas from column references in DQL.
@@ -1634,8 +1644,9 @@ class LineageAnalyzer:
 
                 if actual_table not in self._file_schema:
                     self._file_schema[actual_table] = {}
-                if col_name not in self._file_schema[actual_table]:
-                    self._file_schema[actual_table][col_name] = "UNKNOWN"
+                col_lower = col_name.lower()
+                if col_lower not in self._file_schema[actual_table]:
+                    self._file_schema[actual_table][col_lower] = "UNKNOWN"
 
     def _extract_columns_from_select(
         self, select_node: Union[exp.Select, exp.Union, exp.Intersect, exp.Except]

{sql_glider-0.1.16 → sql_glider-0.1.19}/src/sqlglider/schema/extractor.py

@@ -41,7 +41,14 @@ def extract_schemas_from_files(
     if console is None:
         console = Console(stderr=True)
 
-    schema: SchemaDict = dict(initial_schema) if initial_schema else {}
+    schema: SchemaDict = (
+        {
+            k.lower(): {c.lower(): v for c, v in cols.items()}
+            for k, cols in initial_schema.items()
+        }
+        if initial_schema
+        else {}
+    )
     total = len(file_paths)
 
     with Progress(
@@ -65,7 +72,11 @@ def extract_schemas_from_files(
                     strict_schema=strict_schema,
                 )
                 file_schema = analyzer.extract_schema_only()
-                schema.update(file_schema)
+                for table_name, columns in file_schema.items():
+                    if table_name in schema:
+                        schema[table_name].update(columns)
+                    else:
+                        schema[table_name] = columns
             except SchemaResolutionError:
                 raise
             except Exception:

{sql_glider-0.1.16 → sql_glider-0.1.19}/src/sqlglider/utils/schema.py

@@ -46,7 +46,7 @@ def parse_ddl_to_schema(ddl: str, dialect: str = "spark") -> Dict[str, Dict[str,
         table_name = _get_qualified_name(target)
 
         if columns:
-            schema[table_name] = {col: "UNKNOWN" for col in columns}
+            schema[table_name] = {col.lower(): "UNKNOWN" for col in columns}
 
     return schema
 
@@ -59,4 +59,4 @@ def _get_qualified_name(table: exp.Table) -> str:
     if table.db:
         parts.append(table.db)
     parts.append(table.name)
-    return ".".join(parts)
+    return ".".join(parts).lower()

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

@@ -119,39 +119,39 @@ class TestCaseInsensitiveForwardLineage:
             # Lowercase
             (
                 "target_table.customer_name",
-                "TARGET_TABLE.customer_name",
+                "target_table.customer_name",
                 ["customers.customer_name"],
             ),
             (
                 "target_table.region",
-                "TARGET_TABLE.region",
+                "target_table.region",
                 ["customers.region"],
             ),
             (
                 "target_table.total_amount",
-                "TARGET_TABLE.total_amount",
+                "target_table.total_amount",
                 ["orders.order_amount"],
             ),
             # Uppercase
             (
-                "TARGET_TABLE.CUSTOMER_NAME",
-                "TARGET_TABLE.customer_name",
+                "target_table.CUSTOMER_NAME",
+                "target_table.customer_name",
                 ["customers.customer_name"],
             ),
             (
-                "TARGET_TABLE.REGION",
-                "TARGET_TABLE.region",
+                "target_table.REGION",
+                "target_table.region",
                 ["customers.region"],
             ),
             # Mixed case
             (
                 "TaRgEt_TaBlE.CuStOmEr_NaMe",
-                "TARGET_TABLE.customer_name",
+                "target_table.customer_name",
                 ["customers.customer_name"],
             ),
             (
                 "target_TABLE.REGION",
-                "TARGET_TABLE.region",
+                "target_table.region",
                 ["customers.region"],
             ),
         ],
@@ -346,39 +346,39 @@ class TestCaseInsensitiveReverseLineage:
             (
                 "customers.customer_name",
                 "customers.customer_name",
-                ["TARGET_TABLE.customer_name"],
+                ["target_table.customer_name"],
             ),
             (
                 "customers.region",
                 "customers.region",
-                ["TARGET_TABLE.region"],
+                ["target_table.region"],
             ),
             (
                 "orders.order_amount",
                 "orders.order_amount",
-                ["TARGET_TABLE.segment", "TARGET_TABLE.total_amount"],
+                ["target_table.segment", "target_table.total_amount"],
             ),
             # Uppercase
             (
                 "CUSTOMERS.CUSTOMER_NAME",
                 "customers.customer_name",
-                ["TARGET_TABLE.customer_name"],
+                ["target_table.customer_name"],
             ),
             (
                 "CUSTOMERS.REGION",
                 "customers.region",
-                ["TARGET_TABLE.region"],
+                ["target_table.region"],
             ),
             # Mixed case
             (
                 "CuStOmErS.CuStOmEr_NaMe",
                 "customers.customer_name",
-                ["TARGET_TABLE.customer_name"],
+                ["target_table.customer_name"],
             ),
             (
                 "cUsToMeRs.ReGiOn",
                 "customers.region",
-                ["TARGET_TABLE.region"],
+                ["target_table.region"],
             ),
         ],
     )
@@ -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 *."""

{sql_glider-0.1.16 → sql_glider-0.1.19}/tests/sqlglider/schema/test_extractor.py

@@ -81,6 +81,58 @@ class TestExtractSchemasFromFiles:
         assert "id" in schema["customers"]
         assert "order_id" in schema["orders"]
 
+    def test_merges_columns_for_same_table(self, tmp_path, console):
+        """Test that columns are merged when the same table appears in multiple files."""
+        file1 = tmp_path / "a.sql"
+        file1.write_text("SELECT c.id, c.name FROM customers c;")
+
+        file2 = tmp_path / "b.sql"
+        file2.write_text("SELECT c.id, c.age FROM customers c;")
+
+        schema = extract_schemas_from_files(
+            [file1, file2], dialect="spark", console=console
+        )
+
+        assert "customers" in schema
+        assert "id" in schema["customers"]
+        assert "name" in schema["customers"]
+        assert "age" in schema["customers"]
+
+    def test_merges_columns_case_insensitive(self, tmp_path, console):
+        """Test that tables with different casing are merged into one entry."""
+        file1 = tmp_path / "a.sql"
+        file1.write_text("SELECT c.id, c.name FROM Customers c;")
+
+        file2 = tmp_path / "b.sql"
+        file2.write_text("SELECT c.id, c.AGE FROM customers c;")
+
+        schema = extract_schemas_from_files(
+            [file1, file2], dialect="spark", console=console
+        )
+
+        assert "customers" in schema
+        assert len([k for k in schema if k.lower() == "customers"]) == 1
+        assert "id" in schema["customers"]
+        assert "name" in schema["customers"]
+        assert "age" in schema["customers"]
+
+    def test_initial_schema_normalized(self, tmp_path, console):
+        """Test that initial schema keys are normalized to lowercase."""
+        sql_file = tmp_path / "query.sql"
+        sql_file.write_text("SELECT o.id FROM orders o;")
+
+        initial = {"Existing_Table": {"Col1": "UNKNOWN"}}
+        schema = extract_schemas_from_files(
+            [sql_file],
+            dialect="spark",
+            initial_schema=initial,
+            console=console,
+        )
+
+        assert "existing_table" in schema
+        assert "col1" in schema["existing_table"]
+        assert "orders" in schema
+
     def test_initial_schema_preserved(self, tmp_path, console):
         """Test that initial schema is included in result."""
         sql_file = tmp_path / "query.sql"