sql-glider 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

{sql_glider-0.1.4.dist-info → sql_glider-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-glider
-Version: 0.1.4
+Version: 0.1.5
 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.4.dist-info → sql_glider-0.1.5.dist-info}/RECORD

@@ -1,5 +1,5 @@
 sqlglider/__init__.py,sha256=gDf7s52dMcX7JuCZ1SLawcB1vb3U0yJCohu9RQAATBY,125
-sqlglider/_version.py,sha256=rLCrf4heo25FJtBY-2Ap7ZuWW-5FS7sqTjsolIUuI5c,704
+sqlglider/_version.py,sha256=rdxBMYpwzYxiWk08QbPLHSAxHoDfeKWwyaJIAM0lSic,704
 sqlglider/cli.py,sha256=9sweHRVLk2iBSzCzT2Gcj8y1g1XKzq26iApQsMaFbx4,51786
 sqlglider/global_models.py,sha256=2vyJXAuXOsXQpE-D3F0ejj7eR9z0nDWFjTkielhzM8k,356
 sqlglider/catalog/__init__.py,sha256=2PqFPyzFXJ14FpSUcBmVK2L-a_ypWQHAbHFHxLDk_LE,814
@@ -17,7 +17,7 @@ sqlglider/graph/models.py,sha256=EYmjv_WzDSNp_WfhJ6H-qBIOkAcoNKS7GRUryfKrHuY,933
 sqlglider/graph/query.py,sha256=LHU8Cvn7ZPPSEnqdDn2pF8f1_LQjIvNIrZqs8cFlb6U,9433
 sqlglider/graph/serialization.py,sha256=7JJo31rwSlxnDhdqdTJdK4Dr_ZcSYetXfx3_CmndSac,2662
 sqlglider/lineage/__init__.py,sha256=llXMeI5_PIZaiBo8tKk3-wOubF4m_6QBHbn1FtWxT7k,256
-sqlglider/lineage/analyzer.py,sha256=kRhGcGaiixxtrf9vO8g09omayjB2G3LA9hLCOLaTyPg,56811
+sqlglider/lineage/analyzer.py,sha256=9Ly93TBcpc2sRP9NuwxB0jCL3YK-yCV1rih93MFM-S0,64313
 sqlglider/lineage/formatters.py,sha256=_Y9wcTX4JXn1vVnZ1xI656g1FF2rMjcAVc-GHjbd9QA,10389
 sqlglider/templating/__init__.py,sha256=g3_wb6rSDI0usq2UUMDpn-J5kVwlAw3NtLdwbxL6UHs,1435
 sqlglider/templating/base.py,sha256=y5bWAW7qXl_4pPyo5KycfHwNVvt1-7slZ63DAsvTE1s,2902
@@ -27,8 +27,8 @@ sqlglider/templating/variables.py,sha256=5593PtLBcOxsnMCSRm2pGAD5I0Y9f__VV3_J_Hf
 sqlglider/utils/__init__.py,sha256=KGp9-UzKz_OFBOTFoSy-g-NXDZsvyWXG_9-1zcC6ePE,276
 sqlglider/utils/config.py,sha256=iNJgSXFw3pmL2MCdvW3SJp4X2T3AQP2QyQuXIXT-6H0,4761
 sqlglider/utils/file_utils.py,sha256=5_ff28E0r1R7emZzsOnRuHd-7zIX6873eyr1SuPEr4E,1093
-sql_glider-0.1.4.dist-info/METADATA,sha256=-gzDzEyZ116YpDBNbIwWMgMO184s-WkDKMxMH92lOqA,28445
-sql_glider-0.1.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-sql_glider-0.1.4.dist-info/entry_points.txt,sha256=HDuakHqHS5C0HFKsMIxMYmDU7-BLBGrnIJcYaVRu-s0,251
-sql_glider-0.1.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sql_glider-0.1.4.dist-info/RECORD,,
+sql_glider-0.1.5.dist-info/METADATA,sha256=uLFCtpVoKp5F8ORuqJfJQtNZFjAJ3BQLavtRl-Bh0JA,28445
+sql_glider-0.1.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+sql_glider-0.1.5.dist-info/entry_points.txt,sha256=HDuakHqHS5C0HFKsMIxMYmDU7-BLBGrnIJcYaVRu-s0,251
+sql_glider-0.1.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sql_glider-0.1.5.dist-info/RECORD,,

sqlglider/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.4'
-__version_tuple__ = version_tuple = (0, 1, 4)
+__version__ = version = '0.1.5'
+__version_tuple__ = version_tuple = (0, 1, 5)
 
 __commit_id__ = commit_id = None

sqlglider/lineage/analyzer.py

@@ -182,20 +182,43 @@ class LineageAnalyzer:
                     # For aliased columns, use the alias as the column name
                     column_name = projection.alias
                     lineage_name = column_name  # SQLGlot lineage uses the alias
-                else:
-                    source_expr = projection
-                    if isinstance(source_expr, exp.Column):
-                        column_name = source_expr.name
-                        lineage_name = column_name
+                    # Qualify with target table
+                    qualified_name = f"{target_table}.{column_name}"
+                    columns.append(qualified_name)
+                    self._column_mapping[qualified_name] = lineage_name
+                elif isinstance(projection, exp.Column):
+                    # Check if this is a table-qualified star (e.g., t.*)
+                    if isinstance(projection.this, exp.Star):
+                        source_table = projection.table
+                        qualified_star_cols: List[str] = []
+                        if source_table and first_select:
+                            qualified_star_cols = self._resolve_qualified_star(
+                                source_table, first_select
+                            )
+                            for col in qualified_star_cols:
+                                qualified_name = f"{target_table}.{col}"
+                                columns.append(qualified_name)
+                                self._column_mapping[qualified_name] = col
+                        if not qualified_star_cols:
+                            # Fallback: can't resolve t.*, use * as column name
+                            qualified_name = f"{target_table}.*"
+                            columns.append(qualified_name)
+                            self._column_mapping[qualified_name] = "*"
                     else:
-                        # For expressions, use the SQL representation
-                        column_name = source_expr.sql(dialect=self.dialect)
+                        column_name = projection.name
                         lineage_name = column_name
-
-                # Qualify with target table
-                qualified_name = f"{target_table}.{column_name}"
-                columns.append(qualified_name)
-                self._column_mapping[qualified_name] = lineage_name
+                        # Qualify with target table
+                        qualified_name = f"{target_table}.{column_name}"
+                        columns.append(qualified_name)
+                        self._column_mapping[qualified_name] = lineage_name
+                else:
+                    # For expressions, use the SQL representation
+                    column_name = projection.sql(dialect=self.dialect)
+                    lineage_name = column_name
+                    # Qualify with target table
+                    qualified_name = f"{target_table}.{column_name}"
+                    columns.append(qualified_name)
+                    self._column_mapping[qualified_name] = lineage_name
 
         else:
             # DQL (pure SELECT): Use the SELECT columns as output
@@ -1342,8 +1365,18 @@ class LineageAnalyzer:
                 # Use the alias name as the column name
                 columns.append(projection.alias)
             elif isinstance(projection, exp.Column):
-                # Use the column name
-                columns.append(projection.name)
+                # Check if this is a table-qualified star (e.g., t.*)
+                if isinstance(projection.this, exp.Star):
+                    # Resolve table-qualified star from known schema
+                    table_name = projection.table
+                    if table_name and first_select:
+                        qualified_star_cols = self._resolve_qualified_star(
+                            table_name, first_select
+                        )
+                        columns.extend(qualified_star_cols)
+                else:
+                    # Use the column name
+                    columns.append(projection.name)
             elif isinstance(projection, exp.Star):
                 # Resolve SELECT * from known schema
                 if first_select:
@@ -1375,6 +1408,58 @@ class LineageAnalyzer:
 
         source = from_clause.this
 
+        # Handle table reference from FROM clause
+        columns.extend(self._resolve_source_columns(source, select_node))
+
+        # Handle JOIN clauses - collect columns from all joined tables
+        joins = select_node.args.get("joins")
+        if joins:
+            for join in joins:
+                if isinstance(join, exp.Join):
+                    join_source = join.this
+                    columns.extend(
+                        self._resolve_source_columns(join_source, select_node)
+                    )
+
+        # Handle LATERAL VIEW clauses - collect generated columns
+        laterals = select_node.args.get("laterals")
+        if laterals:
+            for lateral in laterals:
+                if isinstance(lateral, exp.Lateral):
+                    lateral_cols = self._resolve_lateral_columns(lateral)
+                    columns.extend(lateral_cols)
+
+        return columns
+
+    def _resolve_lateral_columns(self, lateral: exp.Lateral) -> List[str]:
+        """
+        Extract generated column names from a LATERAL VIEW clause.
+
+        Args:
+            lateral: The Lateral expression node
+
+        Returns:
+            List of generated column names (e.g., ['elem'] for explode,
+            ['pos', 'elem'] for posexplode)
+        """
+        # Use SQLGlot's built-in property to get alias column names
+        return lateral.alias_column_names or []
+
+    def _resolve_source_columns(
+        self, source: exp.Expression, select_node: exp.Select
+    ) -> List[str]:
+        """
+        Resolve columns from a single source (table, subquery, etc.).
+
+        Args:
+            source: The source expression (Table, Subquery, etc.)
+            select_node: The containing SELECT node for CTE resolution
+
+        Returns:
+            List of column names from the source
+        """
+        columns: List[str] = []
+
         # Handle table reference
         if isinstance(source, exp.Table):
             source_name = self._get_qualified_table_name(source)
@@ -1387,11 +1472,100 @@ class LineageAnalyzer:
                 cte_columns = self._resolve_cte_columns(source_name, select_node)
                 columns.extend(cte_columns)
 
-        # Handle subquery - can't resolve without deeper analysis
-        elif isinstance(source, exp.Subquery) and source.alias:
-            # Check if this subquery alias is in file schema (unlikely)
-            if source.alias in self._file_schema:
+        # Handle subquery with alias
+        elif isinstance(source, exp.Subquery):
+            # First check if this subquery alias is in file schema
+            if source.alias and source.alias in self._file_schema:
                 columns.extend(self._file_schema[source.alias].keys())
+            else:
+                # Extract columns from the subquery's SELECT
+                inner_select = source.this
+                if isinstance(inner_select, exp.Select):
+                    subquery_cols = self._extract_subquery_columns(inner_select)
+                    columns.extend(subquery_cols)
+
+        return columns
+
+    def _resolve_qualified_star(
+        self, table_name: str, select_node: exp.Select
+    ) -> List[str]:
+        """
+        Resolve a table-qualified star (e.g., t.*) to actual column names.
+
+        Args:
+            table_name: The table/alias name qualifying the star
+            select_node: The SELECT node for context
+
+        Returns:
+            List of column names from the specified table
+        """
+        # First check file schema
+        if table_name in self._file_schema:
+            return list(self._file_schema[table_name].keys())
+
+        # Check if it's a CTE reference
+        cte_columns = self._resolve_cte_columns(table_name, select_node)
+        if cte_columns:
+            return cte_columns
+
+        # Check if the table name is an alias - need to resolve the actual table
+        from_clause = select_node.args.get("from")
+        if from_clause and isinstance(from_clause, exp.From):
+            source = from_clause.this
+            if isinstance(source, exp.Table) and source.alias == table_name:
+                actual_name = self._get_qualified_table_name(source)
+                if actual_name in self._file_schema:
+                    return list(self._file_schema[actual_name].keys())
+
+            # Check JOIN clauses for aliased tables
+            joins = select_node.args.get("joins")
+            if joins:
+                for join in joins:
+                    if isinstance(join, exp.Join):
+                        join_source = join.this
+                        if (
+                            isinstance(join_source, exp.Table)
+                            and join_source.alias == table_name
+                        ):
+                            actual_name = self._get_qualified_table_name(join_source)
+                            if actual_name in self._file_schema:
+                                return list(self._file_schema[actual_name].keys())
+
+        return []
+
+    def _extract_subquery_columns(self, subquery_select: exp.Select) -> List[str]:
+        """
+        Extract column names from a subquery's SELECT statement.
+
+        Args:
+            subquery_select: The SELECT expression within the subquery
+
+        Returns:
+            List of column names
+        """
+        columns: List[str] = []
+
+        for projection in subquery_select.expressions:
+            if isinstance(projection, exp.Alias):
+                columns.append(projection.alias)
+            elif isinstance(projection, exp.Column):
+                # Check for table-qualified star (t.*)
+                if isinstance(projection.this, exp.Star):
+                    table_name = projection.table
+                    if table_name:
+                        qualified_cols = self._resolve_qualified_star(
+                            table_name, subquery_select
+                        )
+                        columns.extend(qualified_cols)
+                else:
+                    columns.append(projection.name)
+            elif isinstance(projection, exp.Star):
+                # Resolve SELECT * in subquery
+                star_columns = self._resolve_star_columns(subquery_select)
+                columns.extend(star_columns)
+            else:
+                col_sql = projection.sql(dialect=self.dialect)
+                columns.append(col_sql)
 
         return columns