sqlshell 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

sqlshell/README.md

@@ -1,4 +1,6 @@
-# SQLShell
+# SQLShell - DEPRECATED README
+
+**NOTE: This README is deprecated. Please refer to the main README.md file in the root directory of the repository for the most up-to-date information.**
 
 A powerful SQL shell with GUI interface for data analysis. SQLShell provides an intuitive interface for working with various data formats (CSV, Excel, Parquet) using SQL queries powered by DuckDB.
 
@@ -12,6 +14,7 @@ A powerful SQL shell with GUI interface for data analysis. SQLShell provides an
 - Table preview functionality
 - Built-in test data generation
 - Support for multiple concurrent table views
+- "Explain Column" feature for analyzing relationships between data columns
 
 ## Installation
 
@@ -45,6 +48,7 @@ This will open the GUI interface where you can:
 3. Execute queries using the "Execute" button or Ctrl+Enter
 4. View results in the table view below
 5. Load sample test data using the "Test" button
+6. Right-click on column headers in the results to access features like sorting, filtering, and the "Explain Column" analysis tool
 
 ## Requirements
 

sqlshell/__init__.py

@@ -2,7 +2,7 @@
 SQLShell - A powerful SQL shell with GUI interface for data analysis
 """
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"
 __author__ = "SQLShell Team"
 
 from sqlshell.main import main

sqlshell/create_test_data.py

@@ -10,6 +10,35 @@ np.random.seed(42)
 OUTPUT_DIR = 'test_data'
 os.makedirs(OUTPUT_DIR, exist_ok=True)
 
+def create_california_housing_data(output_file='california_housing_data.parquet'):
+    """Use the real world california housing dataset"""
+    # Load the dataset
+    df = pd.read_csv('https://raw.githubusercontent.com/ageron/handson-ml/master/datasets/housing/housing.csv')
+    
+    # Save to Parquet
+    df.to_parquet(output_file)
+    return df
+
+def create_large_customer_data(num_customers=1_000_000, chunk_size=100_000, output_file='large_customer_data.parquet'):
+    """Create a large customer dataset """
+    # Generate customer data
+    data = {
+        'CustomerID': range(1, num_customers + 1),
+        'FirstName': [f'Customer{i}' for i in range(1, num_customers + 1)],
+        'LastName': [f'Lastname{i}' for i in range(1, num_customers + 1)],
+        'Email': [f'customer{i}@example.com' for i in range(1, num_customers + 1)],
+        'JoinDate': [datetime.now() - timedelta(days=np.random.randint(1, 1000)) 
+                     for _ in range(num_customers)],
+        'CustomerType': np.random.choice(['Regular', 'Premium', 'VIP'], num_customers),
+        'CreditScore': np.random.randint(300, 851, num_customers)
+    }
+    
+    # Create DataFrame
+    df = pd.DataFrame(data)
+    
+    return df
+
+
 def create_sales_data(num_records=1000):
     # Generate dates for the last 365 days
     end_date = datetime.now()

sqlshell/main.py

@@ -188,6 +188,12 @@ class SQLShell(QMainWindow):
         tables_header.setStyleSheet(get_tables_header_stylesheet())
         left_layout.addWidget(tables_header)
         
+        # Tables info label
+        tables_info = QLabel("Right-click on tables to profile columns, analyze structure, and discover distributions. Select multiple tables to analyze foreign key relationships.")
+        tables_info.setWordWrap(True)
+        tables_info.setStyleSheet("color: #7FB3D5; font-size: 11px; margin-top: 2px; margin-bottom: 5px;")
+        left_layout.addWidget(tables_info)
+        
         # Tables list with custom styling
         self.tables_list = DraggableTablesList(self)
         self.tables_list.itemClicked.connect(self.show_table_preview)
@@ -808,25 +814,32 @@ class SQLShell(QMainWindow):
             # Generate test data
             sales_df = create_test_data.create_sales_data()
             customer_df = create_test_data.create_customer_data()
+            large_customer_df = create_test_data.create_large_customer_data()
             product_df = create_test_data.create_product_data()
             large_numbers_df = create_test_data.create_large_numbers_data()
+            california_housing_df = create_test_data.create_california_housing_data()
             
             # Save test data to temporary directory
             sales_path = os.path.join(temp_dir, 'sample_sales_data.xlsx')
             customer_path = os.path.join(temp_dir, 'customer_data.parquet')
             product_path = os.path.join(temp_dir, 'product_catalog.xlsx')
             large_numbers_path = os.path.join(temp_dir, 'large_numbers.xlsx')
-            
+            large_customer_path = os.path.join(temp_dir, 'large_customer_data.parquet')
+            california_housing_path = os.path.join(temp_dir, 'california_housing_data.parquet')
             sales_df.to_excel(sales_path, index=False)
             customer_df.to_parquet(customer_path, index=False)
             product_df.to_excel(product_path, index=False)
             large_numbers_df.to_excel(large_numbers_path, index=False)
-            
+            large_customer_df.to_parquet(large_customer_path, index=False)
+            california_housing_df.to_parquet(california_housing_path, index=False)
+
             # Register the tables in the database manager
             self.db_manager.register_dataframe(sales_df, 'sample_sales_data', sales_path)
             self.db_manager.register_dataframe(product_df, 'product_catalog', product_path)
             self.db_manager.register_dataframe(customer_df, 'customer_data', customer_path)
             self.db_manager.register_dataframe(large_numbers_df, 'large_numbers', large_numbers_path)
+            self.db_manager.register_dataframe(large_customer_df, 'large_customer_data', large_customer_path)
+            self.db_manager.register_dataframe(california_housing_df, 'california_housing_data', california_housing_path)
             
             # Update UI
             self.tables_list.clear()
@@ -1203,6 +1216,30 @@ LIMIT 10
 
     def show_tables_context_menu(self, position):
         """Show context menu for tables list"""
+        # Check if we have multiple selected items
+        selected_items = self.tables_list.selectedItems()
+        if len(selected_items) > 1:
+            # Filter out any folder items from selection
+            table_items = [item for item in selected_items if not self.tables_list.is_folder_item(item)]
+            
+            if len(table_items) > 1:
+                # Create context menu for multiple table selection
+                context_menu = QMenu(self)
+                context_menu.setStyleSheet(get_context_menu_stylesheet())
+                
+                # Add foreign key analysis option
+                analyze_fk_action = context_menu.addAction(f"Analyze Foreign Keys Between {len(table_items)} Tables")
+                analyze_fk_action.setIcon(QIcon.fromTheme("system-search"))
+                
+                # Show menu and get selected action
+                action = context_menu.exec(self.tables_list.mapToGlobal(position))
+                
+                if action == analyze_fk_action:
+                    self.analyze_foreign_keys_between_tables(table_items)
+                
+                return
+        
+        # Single item selection (original functionality)
         item = self.tables_list.itemAt(position)
         
         # If no item or it's a folder, let the tree widget handle it
@@ -1236,6 +1273,10 @@ LIMIT 10
         profile_table_action = context_menu.addAction("Profile Table Structure")
         profile_table_action.setIcon(QIcon.fromTheme("edit-find"))
         
+        # Add distributions profiler action
+        profile_distributions_action = context_menu.addAction("Analyze Column Distributions")
+        profile_distributions_action.setIcon(QIcon.fromTheme("accessories-calculator"))
+        
         # Check if table needs reloading and add appropriate action
         if table_name in self.tables_list.tables_needing_reload:
             reload_action = context_menu.addAction("Reload Table")
@@ -1294,6 +1335,9 @@ LIMIT 10
         elif action == profile_table_action:
             # Call the table profile method
             self.profile_table_structure(table_name)
+        elif action == profile_distributions_action:
+            # Call the distributions profile method
+            self.profile_distributions(table_name)
         elif action == rename_action:
             # Show rename dialog
             new_name, ok = QInputDialog.getText(
@@ -1349,6 +1393,73 @@ LIMIT 10
             if target_folder:
                 self.tables_list.move_item_to_folder(item, target_folder)
                 self.statusBar().showMessage(f'Moved table "{table_name}" to folder "{target_folder.text(0)}"')
+                
+    def analyze_foreign_keys_between_tables(self, table_items):
+        """Analyze foreign key relationships between selected tables"""
+        try:
+            # Show a loading indicator
+            table_count = len(table_items)
+            self.statusBar().showMessage(f'Analyzing foreign key relationships between {table_count} tables...')
+            
+            # Extract table names from selected items
+            table_names = []
+            for item in table_items:
+                table_name = self.tables_list.get_table_name_from_item(item)
+                if table_name:
+                    table_names.append(table_name)
+            
+            if len(table_names) < 2:
+                QMessageBox.warning(self, "Not Enough Tables", 
+                                    "At least two tables are required for foreign key analysis.")
+                return
+            
+            # Check if any tables need to be reloaded
+            tables_to_reload = [tn for tn in table_names if tn in self.tables_list.tables_needing_reload]
+            for table_name in tables_to_reload:
+                # Reload the table immediately
+                self.reload_selected_table(table_name)
+            
+            # Fetch data for each table
+            dfs = []
+            for table_name in table_names:
+                try:
+                    # Get the data as a dataframe
+                    query = f'SELECT * FROM "{table_name}"'
+                    df = self.db_manager.execute_query(query)
+                    
+                    if df is not None and not df.empty:
+                        # Sample large tables to improve performance
+                        if len(df) > 10000:
+                            self.statusBar().showMessage(f'Sampling {table_name} (using 10,000 rows from {len(df)} total)...')
+                            df = df.sample(n=10000, random_state=42)
+                        dfs.append(df)
+                    else:
+                        QMessageBox.warning(self, "Empty Table", 
+                                            f"Table '{table_name}' has no data and will be skipped.")
+                except Exception as e:
+                    QMessageBox.warning(self, "Table Error", 
+                                       f"Error loading table '{table_name}': {str(e)}\nThis table will be skipped.")
+            
+            if len(dfs) < 2:
+                QMessageBox.warning(self, "Not Enough Tables", 
+                                   "At least two tables with data are required for foreign key analysis.")
+                return
+            
+            # Import the foreign key analyzer
+            from sqlshell.utils.profile_foreign_keys import visualize_foreign_keys
+            
+            # Create and show the visualization
+            self.statusBar().showMessage(f'Analyzing foreign key relationships between {len(dfs)} tables...')
+            vis = visualize_foreign_keys(dfs, table_names)
+            
+            # Store a reference to prevent garbage collection
+            self._fk_analysis_window = vis
+            
+            self.statusBar().showMessage(f'Foreign key analysis complete for {len(dfs)} tables')
+            
+        except Exception as e:
+            QMessageBox.critical(self, "Analysis Error", f"Error analyzing foreign keys:\n\n{str(e)}")
+            self.statusBar().showMessage(f'Error analyzing foreign keys: {str(e)}')
 
     def reload_selected_table(self, table_name=None):
         """Reload the data for a table from its source file"""
@@ -3195,6 +3306,12 @@ LIMIT 10
                 df = self.db_manager.execute_query(query)
                 
                 if df is not None and not df.empty:
+                    # Sample the data if it's larger than 10,000 rows
+                    row_count = len(df)
+                    if row_count > 10000:
+                        self.statusBar().showMessage(f'Sampling {table_name} (using 10,000 rows from {row_count} total)...')
+                        df = df.sample(n=10000, random_state=42)
+                    
                     # Import the key profiler
                     from sqlshell.utils.profile_keys import visualize_profile
                     
@@ -3205,7 +3322,10 @@ LIMIT 10
                     # Store a reference to prevent garbage collection
                     self._keys_profile_window = vis
                     
-                    self.statusBar().showMessage(f'Table structure profile generated for "{table_name}"')
+                    if row_count > 10000:
+                        self.statusBar().showMessage(f'Table structure profile generated for "{table_name}" (sampled 10,000 rows from {row_count})')
+                    else:
+                        self.statusBar().showMessage(f'Table structure profile generated for "{table_name}"')
                 else:
                     QMessageBox.warning(self, "Empty Table", f"Table '{table_name}' has no data to analyze.")
                     self.statusBar().showMessage(f'Table "{table_name}" is empty - cannot analyze')
@@ -3216,6 +3336,97 @@ LIMIT 10
         except Exception as e:
             QMessageBox.critical(self, "Profile Error", f"Error profiling table structure:\n\n{str(e)}")
             self.statusBar().showMessage(f'Error profiling table: {str(e)}')
+    
+    def profile_distributions(self, table_name):
+        """Analyze a table's column distributions to understand data patterns"""
+        try:
+            # Show a loading indicator
+            self.statusBar().showMessage(f'Analyzing column distributions for "{table_name}"...')
+            
+            # Get the table data
+            if table_name in self.db_manager.loaded_tables:
+                # Check if table needs reloading first
+                if table_name in self.tables_list.tables_needing_reload:
+                    # Reload the table immediately
+                    self.reload_selected_table(table_name)
+                
+                # Get the data as a dataframe
+                query = f'SELECT * FROM "{table_name}"'
+                df = self.db_manager.execute_query(query)
+                
+                if df is not None and not df.empty:
+                    # Sample the data if it's larger than 10,000 rows
+                    row_count = len(df)
+                    if row_count > 10000:
+                        self.statusBar().showMessage(f'Sampling {table_name} (using 10,000 rows from {row_count} total)...')
+                        df = df.sample(n=10000, random_state=42)
+                    
+                    # Import the distribution profiler
+                    from sqlshell.utils.profile_distributions import visualize_profile
+                    
+                    # Create and show the visualization
+                    self.statusBar().showMessage(f'Generating distribution profile for "{table_name}"...')
+                    vis = visualize_profile(df)
+                    
+                    # Store a reference to prevent garbage collection
+                    self._distributions_window = vis
+                    
+                    if row_count > 10000:
+                        self.statusBar().showMessage(f'Distribution profile generated for "{table_name}" (sampled 10,000 rows from {row_count})')
+                    else:
+                        self.statusBar().showMessage(f'Distribution profile generated for "{table_name}"')
+                else:
+                    QMessageBox.warning(self, "Empty Table", f"Table '{table_name}' has no data to analyze.")
+                    self.statusBar().showMessage(f'Table "{table_name}" is empty - cannot analyze')
+            else:
+                QMessageBox.warning(self, "Table Not Found", f"Table '{table_name}' not found.")
+                self.statusBar().showMessage(f'Table "{table_name}" not found')
+                
+        except Exception as e:
+            QMessageBox.critical(self, "Profile Error", f"Error analyzing distributions:\n\n{str(e)}")
+            self.statusBar().showMessage(f'Error analyzing distributions: {str(e)}')
+
+    def explain_column(self, column_name):
+        """Analyze a column to explain its relationship with other columns"""
+        try:
+            # Get the current tab
+            current_tab = self.get_current_tab()
+            if not current_tab or current_tab.current_df is None:
+                return
+                
+            # Show a loading indicator
+            self.statusBar().showMessage(f'Analyzing column "{column_name}"...')
+            
+            # Get the dataframe from the current tab
+            df = current_tab.current_df
+            
+            if df is not None and not df.empty:
+                # Sample the data if it's larger than 100 rows for ultra-fast performance
+                row_count = len(df)
+                if row_count > 100:
+                    self.statusBar().showMessage(f'Sampling data (using 100 rows from {row_count} total)...')
+                    df = df.sample(n=100, random_state=42)
+                
+                # Import the column profiler
+                from sqlshell.utils.profile_column import visualize_profile
+                
+                # Create and show the visualization
+                self.statusBar().showMessage(f'Generating column profile for "{column_name}"...')
+                visualize_profile(df, column_name)
+                
+                # We don't need to store a reference since the UI keeps itself alive
+                
+                if row_count > 100:
+                    self.statusBar().showMessage(f'Column profile generated for "{column_name}" (sampled 100 rows from {row_count})')
+                else:
+                    self.statusBar().showMessage(f'Column profile generated for "{column_name}"')
+            else:
+                QMessageBox.warning(self, "Empty Data", "No data available to analyze.")
+                self.statusBar().showMessage(f'No data to analyze')
+                
+        except Exception as e:
+            QMessageBox.critical(self, "Analysis Error", f"Error analyzing column:\n\n{str(e)}")
+            self.statusBar().showMessage(f'Error analyzing column: {str(e)}')
 
 def main():
     # Parse command line arguments

sqlshell/table_list.py

@@ -37,7 +37,7 @@ class DraggableTablesList(QTreeWidget):
         self.setHeaderHidden(True)
         self.setColumnCount(1)
         self.setIndentation(15)  # Smaller indentation for a cleaner look
-        self.setSelectionMode(QTreeWidget.SelectionMode.SingleSelection)
+        self.setSelectionMode(QTreeWidget.SelectionMode.ExtendedSelection)
         self.setExpandsOnDoubleClick(False)  # Handle double-clicks manually
         
         # Apply custom styling
@@ -120,6 +120,95 @@ class DraggableTablesList(QTreeWidget):
     
     def startDrag(self, supportedActions):
         """Override startDrag to customize the drag data."""
+        # Check for multiple selected items
+        selected_items = self.selectedItems()
+        if len(selected_items) > 1:
+            # Only support dragging multiple items to the editor (not for folder management)
+            # Filter out folder items
+            table_items = [item for item in selected_items if not self.is_folder_item(item)]
+            
+            if not table_items:
+                return
+            
+            # Extract table names
+            table_names = [self.get_table_name_from_item(item) for item in table_items]
+            table_names = [name for name in table_names if name]  # Remove None values
+            
+            if not table_names:
+                return
+                
+            # Create mime data with comma-separated table names
+            mime_data = QMimeData()
+            mime_data.setText(", ".join(table_names))
+            
+            # Create drag object
+            drag = QDrag(self)
+            drag.setMimeData(mime_data)
+            
+            # Create a visually appealing drag pixmap
+            font = self.font()
+            font.setBold(True)
+            metrics = self.fontMetrics()
+            
+            # Build a preview label with limited number of tables
+            display_names = table_names[:3]
+            if len(table_names) > 3:
+                display_text = f"{', '.join(display_names)} (+{len(table_names) - 3} more)"
+            else:
+                display_text = ", ".join(display_names)
+                
+            text_width = metrics.horizontalAdvance(display_text)
+            text_height = metrics.height()
+            
+            # Make the pixmap large enough for the text plus padding and a small icon
+            padding = 10
+            pixmap = QPixmap(text_width + padding * 2 + 16, text_height + padding)
+            pixmap.fill(Qt.GlobalColor.transparent)
+            
+            # Begin painting
+            painter = QPainter(pixmap)
+            painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+            
+            # Draw a nice rounded rectangle background
+            bg_color = QColor(44, 62, 80, 220)  # Dark blue with transparency
+            painter.setBrush(QBrush(bg_color))
+            painter.setPen(Qt.PenStyle.NoPen)
+            painter.drawRoundedRect(0, 0, pixmap.width(), pixmap.height(), 5, 5)
+            
+            # Draw text
+            painter.setPen(Qt.GlobalColor.white)
+            painter.setFont(font)
+            painter.drawText(int(padding + 16), int(text_height + (padding / 2) - 2), display_text)
+            
+            # Draw a small database icon (simulated)
+            icon_x = padding / 2
+            icon_y = (pixmap.height() - 12) / 2
+            
+            # Draw a simple database icon as a blue circle with lines
+            table_icon_color = QColor("#3498DB")
+            painter.setBrush(QBrush(table_icon_color))
+            painter.setPen(Qt.GlobalColor.white)
+            painter.drawEllipse(int(icon_x), int(icon_y), 12, 12)
+            
+            # Draw "table" lines inside the circle
+            painter.setPen(Qt.GlobalColor.white)
+            painter.drawLine(int(icon_x + 3), int(icon_y + 4), int(icon_x + 9), int(icon_y + 4))
+            painter.drawLine(int(icon_x + 3), int(icon_y + 6), int(icon_x + 9), int(icon_y + 6))
+            painter.drawLine(int(icon_x + 3), int(icon_y + 8), int(icon_x + 9), int(icon_y + 8))
+            
+            painter.end()
+            
+            # Set the drag pixmap
+            drag.setPixmap(pixmap)
+            
+            # Set hotspot to be at the top-left corner of the text
+            drag.setHotSpot(QPoint(padding, pixmap.height() // 2))
+            
+            # Execute drag operation - only allow copy action for multiple tables
+            drag.exec(Qt.DropAction.CopyAction)
+            return
+            
+        # Single item drag (original functionality)
         item = self.currentItem()
         if not item:
             return

sqlshell/ui/filter_header.py

@@ -88,6 +88,11 @@ class FilterHeader(QHeaderView):
         # Add sort actions
         sort_asc_action = context_menu.addAction("Sort Ascending")
         sort_desc_action = context_menu.addAction("Sort Descending")
+        context_menu.addSeparator()
+        
+        # Add explain column action
+        explain_action = context_menu.addAction("Explain Column")
+        
         context_menu.addSeparator()
         filter_action = context_menu.addAction("Filter...")
         
@@ -127,6 +132,15 @@ class FilterHeader(QHeaderView):
             self.show_filter_menu(logical_index)
         elif action == toggle_bar_action:
             self.toggle_bar_chart(logical_index)
+        elif action == explain_action:
+            # Call the explain_column method on the main window
+            if self.main_window and hasattr(self.main_window, "explain_column"):
+                # Get the column name from the table (if it has a current dataframe)
+                current_tab = self.main_window.get_current_tab()
+                if current_tab and hasattr(current_tab, "current_df") and current_tab.current_df is not None:
+                    if logical_index < len(current_tab.current_df.columns):
+                        column_name = current_tab.current_df.columns[logical_index]
+                        self.main_window.explain_column(column_name)
 
     def set_main_window(self, window):
         """Set the reference to the main window"""