sqlshell 0.1.5__py3-none-any.whl → 0.1.8__py3-none-any.whl

sqlshell/__init__.py

@@ -2,5 +2,7 @@
 SQLShell - A powerful SQL shell with GUI interface for data analysis
 """
 
-__version__ = "0.1.5"
-__author__ = "SQLShell Team" 
+__version__ = "0.1.8"
+__author__ = "SQLShell Team"
+
+# SQLShell package initialization 

sqlshell/create_test_data.py

@@ -0,0 +1,50 @@
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+
+def create_sales_data(num_records=1000):
+    """Create sample sales data"""
+    # Generate random dates within the last year
+    end_date = datetime.now()
+    start_date = end_date - timedelta(days=365)
+    dates = pd.date_range(start=start_date, end=end_date, periods=num_records)
+    
+    # Generate random data
+    data = {
+        'orderid': range(1, num_records + 1),
+        'orderdate': dates,
+        'customerid': np.random.randint(1, 101, num_records),
+        'productid': np.random.randint(1, 51, num_records),
+        'quantity': np.random.randint(1, 11, num_records),
+        'unitprice': np.random.uniform(10.0, 1000.0, num_records).round(2)
+    }
+    
+    return pd.DataFrame(data)
+
+def create_customer_data(num_customers=100):
+    """Create sample customer data"""
+    # Generate random customer data
+    data = {
+        'customerid': range(1, num_customers + 1),
+        'customername': [f"Customer {i}" for i in range(1, num_customers + 1)],
+        'email': [f"customer{i}@example.com" for i in range(1, num_customers + 1)],
+        'country': np.random.choice(['USA', 'UK', 'Canada', 'Australia', 'Germany'], num_customers),
+        'joindate': pd.date_range(start='2020-01-01', periods=num_customers).tolist()
+    }
+    
+    return pd.DataFrame(data)
+
+def create_product_data(num_products=50):
+    """Create sample product data"""
+    categories = ['Electronics', 'Books', 'Clothing', 'Home & Garden', 'Sports']
+    
+    # Generate random product data
+    data = {
+        'productid': range(1, num_products + 1),
+        'productname': [f"Product {i}" for i in range(1, num_products + 1)],
+        'category': np.random.choice(categories, num_products),
+        'baseprice': np.random.uniform(5.0, 500.0, num_products).round(2),
+        'instock': np.random.choice([True, False], num_products, p=[0.8, 0.2])
+    }
+    
+    return pd.DataFrame(data) 

sqlshell/data/create_test_data.py

@@ -0,0 +1,137 @@
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import os
+
+# Set random seed for reproducibility
+np.random.seed(42)
+
+# Define output directory
+OUTPUT_DIR = 'test_data'
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+def create_sales_data(num_records=1000):
+    # Generate dates for the last 365 days
+    end_date = datetime.now()
+    start_date = end_date - timedelta(days=365)
+    dates = [start_date + timedelta(days=x) for x in range(366)]
+    random_dates = np.random.choice(dates, num_records)
+
+    # Create product data
+    products = ['Laptop', 'Smartphone', 'Tablet', 'Monitor', 'Keyboard', 'Mouse', 'Headphones', 'Printer']
+    product_prices = {
+        'Laptop': (800, 2000),
+        'Smartphone': (400, 1200),
+        'Tablet': (200, 800),
+        'Monitor': (150, 500),
+        'Keyboard': (20, 150),
+        'Mouse': (10, 80),
+        'Headphones': (30, 300),
+        'Printer': (100, 400)
+    }
+
+    # Generate random data
+    data = {
+        'OrderID': range(1, num_records + 1),
+        'Date': random_dates,
+        'ProductID': np.random.randint(1, len(products) + 1, num_records),  # Changed to ProductID for joining
+        'Quantity': np.random.randint(1, 11, num_records),
+        'CustomerID': np.random.randint(1, 201, num_records),
+        'Region': np.random.choice(['North', 'South', 'East', 'West'], num_records)
+    }
+
+    # Calculate prices based on product
+    product_list = [products[pid-1] for pid in data['ProductID']]
+    data['Price'] = [np.random.uniform(product_prices[p][0], product_prices[p][1]) 
+                     for p in product_list]
+    data['TotalAmount'] = [price * qty for price, qty in zip(data['Price'], data['Quantity'])]
+
+    # Create DataFrame
+    df = pd.DataFrame(data)
+
+    # Round numerical columns
+    df['Price'] = df['Price'].round(2)
+    df['TotalAmount'] = df['TotalAmount'].round(2)
+
+    # Sort by Date
+    return df.sort_values('Date')
+
+def create_customer_data(num_customers=200):
+    # 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)
+    }
+    
+    return pd.DataFrame(data)
+
+def create_product_data():
+    # Create detailed product information
+    products = {
+        'ProductID': range(1, 9),
+        'ProductName': ['Laptop', 'Smartphone', 'Tablet', 'Monitor', 'Keyboard', 'Mouse', 'Headphones', 'Printer'],
+        'Category': ['Computers', 'Mobile', 'Mobile', 'Accessories', 'Accessories', 'Accessories', 'Audio', 'Peripherals'],
+        'Brand': ['TechPro', 'MobileX', 'TabletCo', 'ViewMax', 'TypeMaster', 'ClickPro', 'SoundMax', 'PrintPro'],
+        'StockQuantity': np.random.randint(50, 500, 8),
+        'MinPrice': [800, 400, 200, 150, 20, 10, 30, 100],
+        'MaxPrice': [2000, 1200, 800, 500, 150, 80, 300, 400],
+        'Weight_kg': [2.5, 0.2, 0.5, 3.0, 0.8, 0.1, 0.3, 5.0],
+        'WarrantyMonths': [24, 12, 12, 36, 12, 12, 24, 12]
+    }
+    
+    return pd.DataFrame(products)
+
+if __name__ == '__main__':
+    # Create and save sales data
+    sales_df = create_sales_data()
+    sales_output = os.path.join(OUTPUT_DIR, 'sample_sales_data.xlsx')
+    sales_df.to_excel(sales_output, index=False)
+    print(f"Created sales data in '{sales_output}'")
+    print(f"Number of sales records: {len(sales_df)}")
+    
+    # Create and save customer data as parquet
+    customer_df = create_customer_data()
+    customer_output = os.path.join(OUTPUT_DIR, 'customer_data.parquet')
+    customer_df.to_parquet(customer_output, index=False)
+    print(f"\nCreated customer data in '{customer_output}'")
+    print(f"Number of customers: {len(customer_df)}")
+    
+    # Create and save product data
+    product_df = create_product_data()
+    product_output = os.path.join(OUTPUT_DIR, 'product_catalog.xlsx')
+    product_df.to_excel(product_output, index=False)
+    print(f"\nCreated product catalog in '{product_output}'")
+    print(f"Number of products: {len(product_df)}")
+    
+    # Print sample queries
+    print("\nSample SQL queries for joining the data:")
+    print("""
+    -- Join sales with customer data
+    SELECT s.*, c.FirstName, c.LastName, c.CustomerType
+    FROM test_data.sample_sales_data s
+    JOIN test_data.customer_data c ON s.CustomerID = c.CustomerID;
+    
+    -- Join sales with product data
+    SELECT s.*, p.ProductName, p.Category, p.Brand
+    FROM test_data.sample_sales_data s
+    JOIN test_data.product_catalog p ON s.ProductID = p.ProductID;
+    
+    -- Three-way join with aggregation
+    SELECT 
+        p.Category,
+        c.CustomerType,
+        COUNT(*) as NumOrders,
+        SUM(s.TotalAmount) as TotalRevenue,
+        AVG(s.Quantity) as AvgQuantity
+    FROM test_data.sample_sales_data s
+    JOIN test_data.customer_data c ON s.CustomerID = c.CustomerID
+    JOIN test_data.product_catalog p ON s.ProductID = p.ProductID
+    GROUP BY p.Category, c.CustomerType
+    ORDER BY p.Category, c.CustomerType;
+    """) 

sqlshell/editor.py

@@ -0,0 +1,355 @@
+from PyQt6.QtWidgets import QPlainTextEdit, QWidget, QCompleter
+from PyQt6.QtCore import Qt, QSize, QRect, QStringListModel
+from PyQt6.QtGui import QFont, QColor, QTextCursor, QPainter, QBrush
+
+class LineNumberArea(QWidget):
+    def __init__(self, editor):
+        super().__init__(editor)
+        self.editor = editor
+
+    def sizeHint(self):
+        return QSize(self.editor.line_number_area_width(), 0)
+
+    def paintEvent(self, event):
+        self.editor.line_number_area_paint_event(event)
+
+class SQLEditor(QPlainTextEdit):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.line_number_area = LineNumberArea(self)
+        
+        # Set monospaced font
+        font = QFont("Consolas", 12)  # Increased font size for better readability
+        font.setFixedPitch(True)
+        self.setFont(font)
+        
+        # Connect signals
+        self.blockCountChanged.connect(self.update_line_number_area_width)
+        self.updateRequest.connect(self.update_line_number_area)
+        
+        # Initialize
+        self.update_line_number_area_width(0)
+        
+        # Set tab width to 4 spaces
+        self.setTabStopDistance(4 * self.fontMetrics().horizontalAdvance(' '))
+        
+        # Set placeholder text
+        self.setPlaceholderText("Enter your SQL query here...")
+        
+        # Initialize completer
+        self.completer = None
+        
+        # SQL Keywords for autocomplete
+        self.sql_keywords = [
+            "SELECT", "FROM", "WHERE", "AND", "OR", "INNER", "OUTER", "LEFT", "RIGHT", "JOIN",
+            "ON", "GROUP", "BY", "HAVING", "ORDER", "LIMIT", "OFFSET", "UNION", "EXCEPT", "INTERSECT",
+            "CREATE", "TABLE", "INDEX", "VIEW", "INSERT", "INTO", "VALUES", "UPDATE", "SET", "DELETE",
+            "TRUNCATE", "ALTER", "ADD", "DROP", "COLUMN", "CONSTRAINT", "PRIMARY", "KEY", "FOREIGN", "REFERENCES",
+            "UNIQUE", "NOT", "NULL", "IS", "DISTINCT", "CASE", "WHEN", "THEN", "ELSE", "END",
+            "AS", "WITH", "BETWEEN", "LIKE", "IN", "EXISTS", "ALL", "ANY", "SOME", "DESC", "ASC",
+            "AVG", "COUNT", "SUM", "MAX", "MIN", "COALESCE", "CAST", "CONVERT"
+        ]
+        
+        # Initialize with SQL keywords
+        self.set_completer(QCompleter(self.sql_keywords))
+        
+        # Set modern selection color
+        self.selection_color = QColor("#3498DB")
+        self.selection_color.setAlpha(50)  # Make it semi-transparent
+
+    def set_completer(self, completer):
+        """Set the completer for the editor"""
+        if self.completer:
+            self.completer.disconnect(self)
+            
+        self.completer = completer
+        
+        if not self.completer:
+            return
+            
+        self.completer.setWidget(self)
+        self.completer.setCompletionMode(QCompleter.CompletionMode.PopupCompletion)
+        self.completer.setCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
+        self.completer.activated.connect(self.insert_completion)
+        
+    def update_completer_model(self, words):
+        """Update the completer model with new words"""
+        if not self.completer:
+            return
+            
+        # Combine SQL keywords with table/column names
+        all_words = self.sql_keywords + words
+        
+        # Create a model with all words
+        model = QStringListModel()
+        model.setStringList(all_words)
+        
+        # Set the model to the completer
+        self.completer.setModel(model)
+        
+    def text_under_cursor(self):
+        """Get the text under the cursor for completion"""
+        tc = self.textCursor()
+        tc.select(QTextCursor.SelectionType.WordUnderCursor)
+        return tc.selectedText()
+        
+    def insert_completion(self, completion):
+        """Insert the completion text"""
+        if self.completer.widget() != self:
+            return
+            
+        tc = self.textCursor()
+        extra = len(completion) - len(self.completer.completionPrefix())
+        tc.movePosition(QTextCursor.MoveOperation.Left)
+        tc.movePosition(QTextCursor.MoveOperation.EndOfWord)
+        tc.insertText(completion[-extra:] + " ")
+        self.setTextCursor(tc)
+        
+    def complete(self):
+        """Show completion popup"""
+        prefix = self.text_under_cursor()
+        
+        if not prefix or len(prefix) < 2:  # Only show completions for words with at least 2 characters
+            if self.completer.popup().isVisible():
+                self.completer.popup().hide()
+            return
+            
+        self.completer.setCompletionPrefix(prefix)
+        
+        # If no completions, hide popup
+        if self.completer.completionCount() == 0:
+            self.completer.popup().hide()
+            return
+            
+        # Get popup and position it under the current text
+        popup = self.completer.popup()
+        popup.setCurrentIndex(self.completer.completionModel().index(0, 0))
+        
+        # Calculate position for the popup
+        cr = self.cursorRect()
+        cr.setWidth(self.completer.popup().sizeHintForColumn(0) + 
+                   self.completer.popup().verticalScrollBar().sizeHint().width())
+        
+        # Show the popup
+        self.completer.complete(cr)
+
+    def keyPressEvent(self, event):
+        # Handle completer popup navigation
+        if self.completer and self.completer.popup().isVisible():
+            # Handle navigation keys for the popup
+            if event.key() in [Qt.Key.Key_Enter, Qt.Key.Key_Return, Qt.Key.Key_Tab, 
+                              Qt.Key.Key_Escape, Qt.Key.Key_Up, Qt.Key.Key_Down]:
+                event.ignore()
+                return
+        
+        # Handle special key combinations
+        if event.key() == Qt.Key.Key_Tab:
+            # Insert 4 spaces instead of a tab character
+            self.insertPlainText("    ")
+            return
+            
+        # Auto-indentation for new lines
+        if event.key() in [Qt.Key.Key_Return, Qt.Key.Key_Enter]:
+            cursor = self.textCursor()
+            block = cursor.block()
+            text = block.text()
+            
+            # Get the indentation of the current line
+            indentation = ""
+            for char in text:
+                if char.isspace():
+                    indentation += char
+                else:
+                    break
+            
+            # Check if line ends with an opening bracket or keywords that should increase indentation
+            increase_indent = ""
+            if text.strip().endswith("(") or any(text.strip().upper().endswith(keyword) for keyword in 
+                                               ["SELECT", "FROM", "WHERE", "GROUP BY", "ORDER BY", "HAVING"]):
+                increase_indent = "    "
+                
+            # Insert new line with proper indentation
+            super().keyPressEvent(event)
+            self.insertPlainText(indentation + increase_indent)
+            return
+            
+        # Handle keyboard shortcuts
+        if event.modifiers() == Qt.KeyboardModifier.ControlModifier:
+            if event.key() == Qt.Key.Key_Space:
+                # Show completion popup
+                self.complete()
+                return
+            elif event.key() == Qt.Key.Key_K:
+                # Comment/uncomment the selected lines
+                self.toggle_comment()
+                return
+                
+        # For normal key presses
+        super().keyPressEvent(event)
+        
+        # Check for autocomplete after typing
+        if event.text() and not event.text().isspace():
+            self.complete()
+
+    def paintEvent(self, event):
+        # Call the parent's paintEvent first
+        super().paintEvent(event)
+        
+        # Get the current cursor
+        cursor = self.textCursor()
+        
+        # If there's a selection, paint custom highlight
+        if cursor.hasSelection():
+            # Create a painter for this widget
+            painter = QPainter(self.viewport())
+            
+            # Get the selection start and end positions
+            start = cursor.selectionStart()
+            end = cursor.selectionEnd()
+            
+            # Create temporary cursor to get the rectangles
+            temp_cursor = QTextCursor(cursor)
+            
+            # Move to start and get the starting position
+            temp_cursor.setPosition(start)
+            start_pos = self.cursorRect(temp_cursor)
+            
+            # Move to end and get the ending position
+            temp_cursor.setPosition(end)
+            end_pos = self.cursorRect(temp_cursor)
+            
+            # Set the highlight color with transparency
+            painter.setBrush(QBrush(self.selection_color))
+            painter.setPen(Qt.PenStyle.NoPen)
+            
+            # Draw the highlight rectangle
+            if start_pos.top() == end_pos.top():
+                # Single line selection
+                painter.drawRect(QRect(start_pos.left(), start_pos.top(),
+                                     end_pos.right() - start_pos.left(), start_pos.height()))
+            else:
+                # Multi-line selection
+                # First line
+                painter.drawRect(QRect(start_pos.left(), start_pos.top(),
+                                     self.viewport().width() - start_pos.left(), start_pos.height()))
+                
+                # Middle lines (if any)
+                if end_pos.top() > start_pos.top() + start_pos.height():
+                    painter.drawRect(QRect(0, start_pos.top() + start_pos.height(),
+                                         self.viewport().width(),
+                                         end_pos.top() - (start_pos.top() + start_pos.height())))
+                
+                # Last line
+                painter.drawRect(QRect(0, end_pos.top(), end_pos.right(), end_pos.height()))
+            
+            painter.end()
+
+    def focusInEvent(self, event):
+        super().focusInEvent(event)
+        # Show temporary hint in status bar when editor gets focus
+        if hasattr(self.parent(), 'statusBar'):
+            self.parent().parent().parent().statusBar().showMessage('Press Ctrl+Space for autocomplete', 2000)
+
+    def toggle_comment(self):
+        cursor = self.textCursor()
+        if cursor.hasSelection():
+            # Get the selected text
+            start = cursor.selectionStart()
+            end = cursor.selectionEnd()
+            
+            # Remember the selection
+            cursor.setPosition(start)
+            start_block = cursor.blockNumber()
+            cursor.setPosition(end)
+            end_block = cursor.blockNumber()
+            
+            # Process each line in the selection
+            cursor.setPosition(start)
+            cursor.beginEditBlock()
+            
+            for _ in range(start_block, end_block + 1):
+                # Move to start of line
+                cursor.movePosition(cursor.MoveOperation.StartOfLine)
+                
+                # Check if the line is already commented
+                line_text = cursor.block().text().lstrip()
+                if line_text.startswith('--'):
+                    # Remove comment
+                    pos = cursor.block().text().find('--')
+                    cursor.setPosition(cursor.block().position() + pos)
+                    cursor.deleteChar()
+                    cursor.deleteChar()
+                else:
+                    # Add comment
+                    cursor.insertText('--')
+                
+                # Move to next line if not at the end
+                if not cursor.atEnd():
+                    cursor.movePosition(cursor.MoveOperation.NextBlock)
+            
+            cursor.endEditBlock()
+        else:
+            # Comment/uncomment current line
+            cursor.movePosition(cursor.MoveOperation.StartOfLine)
+            cursor.movePosition(cursor.MoveOperation.EndOfLine, cursor.MoveMode.KeepAnchor)
+            line_text = cursor.selectedText().lstrip()
+            
+            cursor.movePosition(cursor.MoveOperation.StartOfLine)
+            if line_text.startswith('--'):
+                # Remove comment
+                pos = cursor.block().text().find('--')
+                cursor.setPosition(cursor.block().position() + pos)
+                cursor.deleteChar()
+                cursor.deleteChar()
+            else:
+                # Add comment
+                cursor.insertText('--')
+
+    def line_number_area_width(self):
+        digits = 1
+        max_num = max(1, self.blockCount())
+        while max_num >= 10:
+            max_num //= 10
+            digits += 1
+        
+        space = 3 + self.fontMetrics().horizontalAdvance('9') * digits
+        return space
+
+    def update_line_number_area_width(self, _):
+        self.setViewportMargins(self.line_number_area_width(), 0, 0, 0)
+
+    def update_line_number_area(self, rect, dy):
+        if dy:
+            self.line_number_area.scroll(0, dy)
+        else:
+            self.line_number_area.update(0, rect.y(), self.line_number_area.width(), rect.height())
+        
+        if rect.contains(self.viewport().rect()):
+            self.update_line_number_area_width(0)
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        cr = self.contentsRect()
+        self.line_number_area.setGeometry(QRect(cr.left(), cr.top(), self.line_number_area_width(), cr.height()))
+
+    def line_number_area_paint_event(self, event):
+        painter = QPainter(self.line_number_area)
+        painter.fillRect(event.rect(), QColor("#f0f0f0"))  # Light gray background
+        
+        block = self.firstVisibleBlock()
+        block_number = block.blockNumber()
+        top = round(self.blockBoundingGeometry(block).translated(self.contentOffset()).top())
+        bottom = top + round(self.blockBoundingRect(block).height())
+        
+        while block.isValid() and top <= event.rect().bottom():
+            if block.isVisible() and bottom >= event.rect().top():
+                number = str(block_number + 1)
+                painter.setPen(QColor("#808080"))  # Gray text
+                painter.drawText(0, top, self.line_number_area.width() - 5, 
+                                self.fontMetrics().height(),
+                                Qt.AlignmentFlag.AlignRight, number)
+            
+            block = block.next()
+            top = bottom
+            bottom = top + round(self.blockBoundingRect(block).height())
+            block_number += 1