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

sqlshell/main.py

@@ -1,5 +1,12 @@
 import sys
 import os
+import json
+
+# Ensure proper path setup for resources when running directly
+if __name__ == "__main__":
+    project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    sys.path.insert(0, project_root)
+
 import duckdb
 import sqlite3
 import pandas as pd
@@ -8,493 +15,471 @@ from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout,
                            QLabel, QSplitter, QListWidget, QTableWidget,
                            QTableWidgetItem, QHeaderView, QMessageBox, QPlainTextEdit,
                            QCompleter, QFrame, QToolButton, QSizePolicy, QTabWidget,
-                           QStyleFactory, QToolBar, QStatusBar)
-from PyQt6.QtCore import Qt, QAbstractTableModel, QRegularExpression, QRect, QSize, QStringListModel, QPropertyAnimation, QEasingCurve
-from PyQt6.QtGui import QFont, QColor, QSyntaxHighlighter, QTextCharFormat, QPainter, QTextFormat, QTextCursor, QIcon, QPalette, QLinearGradient, QBrush, QPixmap
+                           QStyleFactory, QToolBar, QStatusBar, QLineEdit, QMenu,
+                           QCheckBox, QWidgetAction, QMenuBar, QInputDialog,
+                           QStyledItemDelegate)
+from PyQt6.QtCore import Qt, QAbstractTableModel, QRegularExpression, QRect, QSize, QStringListModel, QPropertyAnimation, QEasingCurve, QTimer, QPoint
+from PyQt6.QtGui import QFont, QColor, QSyntaxHighlighter, QTextCharFormat, QPainter, QTextFormat, QTextCursor, QIcon, QPalette, QLinearGradient, QBrush, QPixmap, QPolygon, QPainterPath
 import numpy as np
 from datetime import datetime
-from sqlshell.sqlshell import create_test_data  # Import from the correct location
 
-class SQLSyntaxHighlighter(QSyntaxHighlighter):
-    def __init__(self, document):
-        super().__init__(document)
-        self.highlighting_rules = []
+from sqlshell import create_test_data
+from sqlshell.splash_screen import AnimatedSplashScreen
+from sqlshell.syntax_highlighter import SQLSyntaxHighlighter
+from sqlshell.editor import LineNumberArea, SQLEditor
 
-        # SQL Keywords
-        keyword_format = QTextCharFormat()
-        keyword_format.setForeground(QColor("#0000FF"))  # Blue
-        keyword_format.setFontWeight(QFont.Weight.Bold)
-        keywords = [
-            "\\bSELECT\\b", "\\bFROM\\b", "\\bWHERE\\b", "\\bAND\\b", "\\bOR\\b",
-            "\\bINNER\\b", "\\bOUTER\\b", "\\bLEFT\\b", "\\bRIGHT\\b", "\\bJOIN\\b",
-            "\\bON\\b", "\\bGROUP\\b", "\\bBY\\b", "\\bHAVING\\b", "\\bORDER\\b",
-            "\\bLIMIT\\b", "\\bOFFSET\\b", "\\bUNION\\b", "\\bEXCEPT\\b", "\\bINTERSECT\\b",
-            "\\bCREATE\\b", "\\bTABLE\\b", "\\bINDEX\\b", "\\bVIEW\\b", "\\bINSERT\\b",
-            "\\bINTO\\b", "\\bVALUES\\b", "\\bUPDATE\\b", "\\bSET\\b", "\\bDELETE\\b",
-            "\\bTRUNCATE\\b", "\\bALTER\\b", "\\bADD\\b", "\\bDROP\\b", "\\bCOLUMN\\b",
-            "\\bCONSTRAINT\\b", "\\bPRIMARY\\b", "\\bKEY\\b", "\\bFOREIGN\\b", "\\bREFERENCES\\b",
-            "\\bUNIQUE\\b", "\\bNOT\\b", "\\bNULL\\b", "\\bIS\\b", "\\bDISTINCT\\b",
-            "\\bCASE\\b", "\\bWHEN\\b", "\\bTHEN\\b", "\\bELSE\\b", "\\bEND\\b",
-            "\\bAS\\b", "\\bWITH\\b", "\\bBETWEEN\\b", "\\bLIKE\\b", "\\bIN\\b",
-            "\\bEXISTS\\b", "\\bALL\\b", "\\bANY\\b", "\\bSOME\\b", "\\bDESC\\b", "\\bASC\\b"
-        ]
-        for pattern in keywords:
-            regex = QRegularExpression(pattern, QRegularExpression.PatternOption.CaseInsensitiveOption)
-            self.highlighting_rules.append((regex, keyword_format))
+class BarChartDelegate(QStyledItemDelegate):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.min_val = 0
+        self.max_val = 1
+        self.bar_color = QColor("#3498DB")
 
-        # Functions
-        function_format = QTextCharFormat()
-        function_format.setForeground(QColor("#AA00AA"))  # Purple
-        functions = [
-            "\\bAVG\\b", "\\bCOUNT\\b", "\\bSUM\\b", "\\bMAX\\b", "\\bMIN\\b",
-            "\\bCOALESCE\\b", "\\bNVL\\b", "\\bNULLIF\\b", "\\bCAST\\b", "\\bCONVERT\\b",
-            "\\bLOWER\\b", "\\bUPPER\\b", "\\bTRIM\\b", "\\bLTRIM\\b", "\\bRTRIM\\b",
-            "\\bLENGTH\\b", "\\bSUBSTRING\\b", "\\bREPLACE\\b", "\\bCONCAT\\b",
-            "\\bROUND\\b", "\\bFLOOR\\b", "\\bCEIL\\b", "\\bABS\\b", "\\bMOD\\b",
-            "\\bCURRENT_DATE\\b", "\\bCURRENT_TIME\\b", "\\bCURRENT_TIMESTAMP\\b",
-            "\\bEXTRACT\\b", "\\bDATE_PART\\b", "\\bTO_CHAR\\b", "\\bTO_DATE\\b"
-        ]
-        for pattern in functions:
-            regex = QRegularExpression(pattern, QRegularExpression.PatternOption.CaseInsensitiveOption)
-            self.highlighting_rules.append((regex, function_format))
+    def set_range(self, min_val, max_val):
+        self.min_val = min_val
+        self.max_val = max_val
 
-        # Numbers
-        number_format = QTextCharFormat()
-        number_format.setForeground(QColor("#009900"))  # Green
-        self.highlighting_rules.append((
-            QRegularExpression("\\b[0-9]+\\b"),
-            number_format
-        ))
+    def paint(self, painter, option, index):
+        # Draw the default background
+        super().paint(painter, option, index)
+        
+        try:
+            text = index.data()
+            value = float(text.replace(',', ''))
+            
+            # Calculate normalized value
+            range_val = self.max_val - self.min_val if self.max_val != self.min_val else 1
+            normalized = (value - self.min_val) / range_val
+            
+            # Define bar dimensions
+            bar_height = 16
+            max_bar_width = 100
+            bar_width = max(5, int(max_bar_width * normalized))
+            
+            # Calculate positions
+            text_width = option.fontMetrics.horizontalAdvance(text) + 10
+            bar_x = option.rect.left() + text_width + 10
+            bar_y = option.rect.center().y() - bar_height // 2
+            
+            # Draw the bar
+            bar_rect = QRect(bar_x, bar_y, bar_width, bar_height)
+            painter.fillRect(bar_rect, self.bar_color)
+            
+            # Draw the text
+            text_rect = QRect(option.rect.left() + 4, option.rect.top(),
+                            text_width, option.rect.height())
+            painter.drawText(text_rect, Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter, text)
+            
+        except (ValueError, AttributeError):
+            # If not a number, just draw the text
+            super().paint(painter, option, index)
 
-        # Single-line string literals
-        string_format = QTextCharFormat()
-        string_format.setForeground(QColor("#CC6600"))  # Orange/Brown
-        self.highlighting_rules.append((
-            QRegularExpression("'[^']*'"),
-            string_format
-        ))
-        self.highlighting_rules.append((
-            QRegularExpression("\"[^\"]*\""),
-            string_format
-        ))
+class FilterHeader(QHeaderView):
+    def __init__(self, parent=None):
+        super().__init__(Qt.Orientation.Horizontal, parent)
+        self.filter_buttons = []
+        self.active_filters = {}  # Track active filters for each column
+        self.columns_with_bars = set()  # Track which columns show bar charts
+        self.bar_delegates = {}  # Store delegates for columns with bars
+        self.setSectionsClickable(True)
+        self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        self.customContextMenuRequested.connect(self.show_header_context_menu)
+        self.main_window = None  # Store reference to main window
+        self.filter_icon_color = QColor("#3498DB")  # Bright blue color for filter icon
 
-        # Comments
-        comment_format = QTextCharFormat()
-        comment_format.setForeground(QColor("#777777"))  # Gray
-        comment_format.setFontItalic(True)
-        self.highlighting_rules.append((
-            QRegularExpression("--[^\n]*"),
-            comment_format
-        ))
-        
-        # Multi-line comments
-        self.comment_start_expression = QRegularExpression("/\\*")
-        self.comment_end_expression = QRegularExpression("\\*/")
-        self.multi_line_comment_format = comment_format
+    def toggle_bar_chart(self, column_index):
+        """Toggle bar chart visualization for a column"""
+        table = self.parent()
+        if not table:
+            return
 
-    def highlightBlock(self, text):
-        # Apply regular expression highlighting rules
-        for pattern, format in self.highlighting_rules:
-            match_iterator = pattern.globalMatch(text)
-            while match_iterator.hasNext():
-                match = match_iterator.next()
-                self.setFormat(match.capturedStart(), match.capturedLength(), format)
+        if column_index in self.columns_with_bars:
+            # Remove bars
+            self.columns_with_bars.remove(column_index)
+            if column_index in self.bar_delegates:
+                table.setItemDelegateForColumn(column_index, None)
+                del self.bar_delegates[column_index]
+        else:
+            # Add bars
+            self.columns_with_bars.add(column_index)
+            
+            # Get all values for normalization
+            values = []
+            for row in range(table.rowCount()):
+                item = table.item(row, column_index)
+                if item:
+                    try:
+                        value = float(item.text().replace(',', ''))
+                        values.append(value)
+                    except ValueError:
+                        continue
 
-        # Handle multi-line comments
-        self.setCurrentBlockState(0)
-        
-        # If previous block was inside a comment, check if this block continues it
-        start_index = 0
-        if self.previousBlockState() != 1:
-            # Find the start of a comment
-            start_match = self.comment_start_expression.match(text)
-            if start_match.hasMatch():
-                start_index = start_match.capturedStart()
-            else:
+            if not values:
                 return
-            
-        while start_index >= 0:
-            # Find the end of the comment
-            end_match = self.comment_end_expression.match(text, start_index)
-            
-            # If end match found
-            if end_match.hasMatch():
-                end_index = end_match.capturedStart()
-                comment_length = end_index - start_index + end_match.capturedLength()
-                self.setFormat(start_index, comment_length, self.multi_line_comment_format)
-                
-                # Look for next comment
-                start_match = self.comment_start_expression.match(text, start_index + comment_length)
-                if start_match.hasMatch():
-                    start_index = start_match.capturedStart()
-                else:
-                    start_index = -1
-            else:
-                # No end found, comment continues to next block
-                self.setCurrentBlockState(1)  # Still inside comment
-                comment_length = len(text) - start_index
-                self.setFormat(start_index, comment_length, self.multi_line_comment_format)
-                start_index = -1
 
-class LineNumberArea(QWidget):
-    def __init__(self, editor):
-        super().__init__(editor)
-        self.editor = editor
+            # Calculate min and max for normalization
+            min_val = min(values)
+            max_val = max(values)
+            
+            # Create and set up delegate
+            delegate = BarChartDelegate(table)
+            delegate.set_range(min_val, max_val)
+            self.bar_delegates[column_index] = delegate
+            table.setItemDelegateForColumn(column_index, delegate)
 
-    def sizeHint(self):
-        return QSize(self.editor.line_number_area_width(), 0)
+        # Update the view
+        table.viewport().update()
 
-    def paintEvent(self, event):
-        self.editor.line_number_area_paint_event(event)
+    def show_header_context_menu(self, pos):
+        """Show context menu for header section"""
+        logical_index = self.logicalIndexAt(pos)
+        if logical_index < 0:
+            return
 
-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
+        # Create context menu
+        context_menu = QMenu(self)
+        context_menu.setStyleSheet("""
+            QMenu {
+                background-color: white;
+                border: 1px solid #BDC3C7;
+                padding: 5px;
+            }
+            QMenu::item {
+                padding: 5px 20px;
+            }
+            QMenu::item:selected {
+                background-color: #3498DB;
+                color: white;
+            }
+        """)
 
-    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:
+        # Add sort actions
+        sort_asc_action = context_menu.addAction("Sort Ascending")
+        sort_desc_action = context_menu.addAction("Sort Descending")
+        context_menu.addSeparator()
+        filter_action = context_menu.addAction("Filter...")
+        
+        # Add bar chart action if column is numeric
+        table = self.parent()
+        if table and table.rowCount() > 0:
+            try:
+                # Check if column contains numeric values
+                sample_value = table.item(0, logical_index).text()
+                float(sample_value.replace(',', ''))  # Try converting to float
+                
+                context_menu.addSeparator()
+                toggle_bar_action = context_menu.addAction(
+                    "Remove Bar Chart" if logical_index in self.columns_with_bars 
+                    else "Add Bar Chart"
+                )
+            except (ValueError, AttributeError):
+                toggle_bar_action = None
+        else:
+            toggle_bar_action = None
+
+        # Show menu and get selected action
+        action = context_menu.exec(self.mapToGlobal(pos))
+
+        if not action:
             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:
+
+        table = self.parent()
+        if not table:
             return
+
+        if action == sort_asc_action:
+            table.sortItems(logical_index, Qt.SortOrder.AscendingOrder)
+        elif action == sort_desc_action:
+            table.sortItems(logical_index, Qt.SortOrder.DescendingOrder)
+        elif action == filter_action:
+            self.show_filter_menu(logical_index)
+        elif action == toggle_bar_action:
+            self.toggle_bar_chart(logical_index)
+
+    def set_main_window(self, window):
+        """Set the reference to the main window"""
+        self.main_window = window
+        
+    def paintSection(self, painter, rect, logical_index):
+        """Override paint section to add filter indicator"""
+        super().paintSection(painter, rect, logical_index)
+        
+        if logical_index in self.active_filters:
+            # Draw background highlight for filtered columns
+            highlight_color = QColor(52, 152, 219, 30)  # Light blue background
+            painter.fillRect(rect, highlight_color)
+            
+            # Make icon larger and more visible
+            icon_size = min(rect.height() - 8, 24)  # Larger icon, but not too large
+            margin = 6
+            icon_rect = QRect(
+                rect.right() - icon_size - margin,
+                rect.top() + (rect.height() - icon_size) // 2,
+                icon_size,
+                icon_size
+            )
             
-        # 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:
+            # Draw filter icon with improved visibility
+            painter.save()
+            
+            # Set up the pen for better visibility
+            pen = painter.pen()
+            pen.setWidth(3)  # Thicker lines
+            pen.setColor(self.filter_icon_color)
+            painter.setPen(pen)
+            
+            # Calculate points for larger funnel shape
+            points = [
+                QPoint(icon_rect.left(), icon_rect.top()),
+                QPoint(icon_rect.right(), icon_rect.top()),
+                QPoint(icon_rect.center().x() + icon_size//3, icon_rect.center().y()),
+                QPoint(icon_rect.center().x() + icon_size//3, icon_rect.bottom()),
+                QPoint(icon_rect.center().x() - icon_size//3, icon_rect.bottom()),
+                QPoint(icon_rect.center().x() - icon_size//3, icon_rect.center().y()),
+                QPoint(icon_rect.left(), icon_rect.top())
+            ]
+            
+            # Create and fill path
+            path = QPainterPath()
+            path.moveTo(float(points[0].x()), float(points[0].y()))
+            for point in points[1:]:
+                path.lineTo(float(point.x()), float(point.y()))
+            
+            # Fill with semi-transparent blue
+            painter.fillPath(path, QBrush(QColor(52, 152, 219, 120)))  # More opaque fill
+            
+            # Draw outline
+            painter.drawPolyline(QPolygon(points))
+            
+            # If multiple values are filtered, add a number
+            if len(self.active_filters[logical_index]) > 1:
+                # Draw number with better visibility
+                number_rect = QRect(icon_rect.left(), icon_rect.top(),
+                                  icon_rect.width(), icon_rect.height())
+                painter.setFont(QFont("Arial", icon_size//2, QFont.Weight.Bold))
+                
+                # Draw text shadow for better contrast
+                painter.setPen(QColor("white"))
+                painter.drawText(number_rect.adjusted(1, 1, 1, 1),
+                               Qt.AlignmentFlag.AlignCenter,
+                               str(len(self.active_filters[logical_index])))
+                
+                # Draw main text
+                painter.setPen(self.filter_icon_color)
+                painter.drawText(number_rect, Qt.AlignmentFlag.AlignCenter,
+                               str(len(self.active_filters[logical_index])))
+            
+            painter.restore()
+            
+            # Draw a more visible indicator at the bottom of the header section
+            painter.save()
+            indicator_height = 3  # Thicker indicator line
+            indicator_rect = QRect(rect.left(), rect.bottom() - indicator_height,
+                                 rect.width(), indicator_height)
+            painter.fillRect(indicator_rect, self.filter_icon_color)
+            painter.restore()
+        
+    def show_filter_menu(self, logical_index):
+        if not self.parent() or not isinstance(self.parent(), QTableWidget):
             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)
+        table = self.parent()
+        unique_values = set()
         
-    def complete(self):
-        """Show completion popup"""
-        prefix = self.text_under_cursor()
+        # Collect unique values from the column
+        for row in range(table.rowCount()):
+            item = table.item(row, logical_index)
+            if item and not table.isRowHidden(row):
+                unique_values.add(item.text())
         
-        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)
+        # Create and show the filter menu
+        menu = QMenu(self)
+        menu.setStyleSheet("""
+            QMenu {
+                background-color: white;
+                border: 1px solid #BDC3C7;
+                padding: 5px;
+            }
+            QMenu::item {
+                padding: 5px 20px;
+            }
+            QMenu::item:selected {
+                background-color: #3498DB;
+                color: white;
+            }
+            QCheckBox {
+                padding: 5px;
+            }
+            QScrollArea {
+                border: none;
+            }
+        """)
         
-        # 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))
+        # Add search box at the top
+        search_widget = QWidget(menu)
+        search_layout = QVBoxLayout(search_widget)
+        search_edit = QLineEdit(search_widget)
+        search_edit.setPlaceholderText("Search values...")
+        search_layout.addWidget(search_edit)
+        
+        # Add action for search widget
+        search_action = QWidgetAction(menu)
+        search_action.setDefaultWidget(search_widget)
+        menu.addAction(search_action)
+        menu.addSeparator()
+        
+        # Add "Select All" checkbox
+        select_all = QCheckBox("Select All", menu)
+        select_all.setChecked(True)
+        select_all_action = QWidgetAction(menu)
+        select_all_action.setDefaultWidget(select_all)
+        menu.addAction(select_all_action)
+        menu.addSeparator()
+        
+        # Create scrollable area for checkboxes
+        scroll_widget = QWidget(menu)
+        scroll_layout = QVBoxLayout(scroll_widget)
+        scroll_layout.setSpacing(2)
+        scroll_layout.setContentsMargins(0, 0, 0, 0)
+        
+        # Add checkboxes for unique values
+        value_checkboxes = {}
+        for value in sorted(unique_values):
+            checkbox = QCheckBox(str(value), scroll_widget)
+            # Set checked state based on active filters
+            checkbox.setChecked(logical_index not in self.active_filters or 
+                              value in self.active_filters[logical_index])
+            value_checkboxes[value] = checkbox
+            scroll_layout.addWidget(checkbox)
+        
+        # Add scrollable area to menu
+        scroll_action = QWidgetAction(menu)
+        scroll_action.setDefaultWidget(scroll_widget)
+        menu.addAction(scroll_action)
+        
+        # Connect search box to filter checkboxes
+        def filter_checkboxes(text):
+            for value, checkbox in value_checkboxes.items():
+                checkbox.setVisible(text.lower() in str(value).lower())
+        
+        search_edit.textChanged.connect(filter_checkboxes)
+        
+        # Connect select all to other checkboxes
+        def toggle_all(state):
+            for checkbox in value_checkboxes.values():
+                if not checkbox.isHidden():  # Only toggle visible checkboxes
+                    checkbox.setChecked(state)
+        
+        select_all.stateChanged.connect(toggle_all)
+        
+        # Add Apply and Clear buttons
+        menu.addSeparator()
+        apply_button = QPushButton("Apply Filter", menu)
+        apply_button.setStyleSheet("""
+            QPushButton {
+                background-color: #2ECC71;
+                color: white;
+                border: none;
+                padding: 5px 15px;
+                border-radius: 3px;
+            }
+            QPushButton:hover {
+                background-color: #27AE60;
+            }
+        """)
         
-        # Calculate position for the popup
-        cr = self.cursorRect()
-        cr.setWidth(self.completer.popup().sizeHintForColumn(0) + 
-                   self.completer.popup().verticalScrollBar().sizeHint().width())
+        clear_button = QPushButton("Clear Filter", menu)
+        clear_button.setStyleSheet("""
+            QPushButton {
+                background-color: #E74C3C;
+                color: white;
+                border: none;
+                padding: 5px 15px;
+                border-radius: 3px;
+            }
+            QPushButton:hover {
+                background-color: #C0392B;
+            }
+        """)
         
-        # 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
+        button_widget = QWidget(menu)
+        button_layout = QHBoxLayout(button_widget)
+        button_layout.addWidget(apply_button)
+        button_layout.addWidget(clear_button)
         
-        # 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)
+        button_action = QWidgetAction(menu)
+        button_action.setDefaultWidget(button_widget)
+        menu.addAction(button_action)
         
-        # 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)
+        def apply_filter():
+            # Get selected values
+            selected_values = {value for value, checkbox in value_checkboxes.items() 
+                             if checkbox.isChecked()}
             
-            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()
+            if len(selected_values) < len(unique_values):
+                # Store active filter only if not all values are selected
+                self.active_filters[logical_index] = selected_values
             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
+                # Remove filter if all values are selected
+                self.active_filters.pop(logical_index, None)
+            
+            # Apply all active filters
+            self.apply_all_filters(table)
+            
+            menu.close()
+            self.updateSection(logical_index)  # Redraw section to show/hide filter icon
+        
+        def clear_filter():
+            # Remove filter for this column
+            if logical_index in self.active_filters:
+                del self.active_filters[logical_index]
+            
+            # Apply remaining filters
+            self.apply_all_filters(table)
+            
+            menu.close()
+            self.updateSection(logical_index)  # Redraw section to hide filter icon
+        
+        apply_button.clicked.connect(apply_filter)
+        clear_button.clicked.connect(clear_filter)
+        
+        # Show menu under the header section
+        header_pos = self.mapToGlobal(self.geometry().bottomLeft())
+        header_pos.setX(header_pos.x() + self.sectionPosition(logical_index))
+        menu.exec(header_pos)
+        
+    def apply_all_filters(self, table):
+        """Apply all active filters to the table"""
+        # Show all rows first
+        for row in range(table.rowCount()):
+            table.setRowHidden(row, False)
+        
+        # Apply each active filter
+        for col_idx, allowed_values in self.active_filters.items():
+            for row in range(table.rowCount()):
+                item = table.item(row, col_idx)
+                if item and not table.isRowHidden(row):
+                    table.setRowHidden(row, item.text() not in allowed_values)
+        
+        # Update status bar with visible row count
+        if self.main_window:
+            visible_rows = sum(1 for row in range(table.rowCount()) 
+                             if not table.isRowHidden(row))
+            total_filters = len(self.active_filters)
+            filter_text = f" ({total_filters} filter{'s' if total_filters != 1 else ''} active)" if total_filters > 0 else ""
+            self.main_window.statusBar().showMessage(
+                f"Showing {visible_rows:,} rows{filter_text}")
 
 class SQLShell(QMainWindow):
     def __init__(self):
         super().__init__()
-        self.current_db_type = 'duckdb'  # Default to DuckDB
-        self.conn = duckdb.connect(':memory:')  # Create in-memory DuckDB connection by default
+        self.conn = None
+        self.current_connection_type = None
         self.loaded_tables = {}  # Keep track of loaded tables
         self.table_columns = {}  # Keep track of table columns
+        self.current_df = None  # Store the current DataFrame for filtering
+        self.filter_widgets = []  # Store filter line edits
+        self.current_project_file = None  # Store the current project file path
         
         # Define color scheme
         self.colors = {
@@ -674,6 +659,33 @@ class SQLShell(QMainWindow):
         self.setWindowTitle('SQL Shell')
         self.setGeometry(100, 100, 1400, 800)
         
+        # Create menu bar
+        menubar = self.menuBar()
+        file_menu = menubar.addMenu('&File')
+        
+        # Project management actions
+        new_project_action = file_menu.addAction('New Project')
+        new_project_action.setShortcut('Ctrl+N')
+        new_project_action.triggered.connect(self.new_project)
+        
+        open_project_action = file_menu.addAction('Open Project...')
+        open_project_action.setShortcut('Ctrl+O')
+        open_project_action.triggered.connect(self.open_project)
+        
+        save_project_action = file_menu.addAction('Save Project')
+        save_project_action.setShortcut('Ctrl+S')
+        save_project_action.triggered.connect(self.save_project)
+        
+        save_project_as_action = file_menu.addAction('Save Project As...')
+        save_project_as_action.setShortcut('Ctrl+Shift+S')
+        save_project_as_action.triggered.connect(self.save_project_as)
+        
+        file_menu.addSeparator()
+        
+        exit_action = file_menu.addAction('Exit')
+        exit_action.setShortcut('Ctrl+Q')
+        exit_action.triggered.connect(self.close)
+        
         # Create custom status bar
         status_bar = QStatusBar()
         self.setStatusBar(status_bar)
@@ -759,6 +771,8 @@ class SQLShell(QMainWindow):
             }
         """)
         self.tables_list.itemClicked.connect(self.show_table_preview)
+        self.tables_list.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        self.tables_list.customContextMenuRequested.connect(self.show_tables_context_menu)
         left_layout.addWidget(self.tables_list)
         
         # Add spacer at the bottom
@@ -856,8 +870,14 @@ class SQLShell(QMainWindow):
         self.results_table = QTableWidget()
         self.results_table.setSortingEnabled(True)
         self.results_table.setAlternatingRowColors(True)
-        self.results_table.horizontalHeader().setStretchLastSection(True)
-        self.results_table.horizontalHeader().setSectionsMovable(True)
+        
+        # Set custom header for filtering
+        header = FilterHeader(self.results_table)
+        header.set_main_window(self)  # Set reference to main window
+        self.results_table.setHorizontalHeader(header)
+        header.setStretchLastSection(True)
+        header.setSectionsMovable(True)
+        
         self.results_table.verticalHeader().setVisible(False)
         self.results_table.setShowGrid(True)
         self.results_table.setGridStyle(Qt.PenStyle.SolidLine)
@@ -890,83 +910,141 @@ class SQLShell(QMainWindow):
             "Ctrl+Space: Show autocomplete"
         )
 
-    def format_value(self, value):
-        """Format values for display"""
-        if pd.isna(value):
-            return 'NULL'
-        elif isinstance(value, (int, np.integer)):
-            return f"{value:,}"
-        elif isinstance(value, (float, np.floating)):
-            return f"{value:,.2f}"
-        elif isinstance(value, (datetime, pd.Timestamp)):
-            return value.strftime('%Y-%m-%d %H:%M:%S')
-        return str(value)
-
     def populate_table(self, df):
-        """Populate the table widget with DataFrame content"""
-        if len(df) == 0:
+        """Populate the results table with DataFrame data using memory-efficient chunking"""
+        try:
+            # Store the current DataFrame for filtering
+            self.current_df = df.copy()
+            
+            # Remember which columns had bar charts
+            header = self.results_table.horizontalHeader()
+            if isinstance(header, FilterHeader):
+                columns_with_bars = header.columns_with_bars.copy()
+            else:
+                columns_with_bars = set()
+            
+            # Clear existing data
+            self.results_table.clearContents()
             self.results_table.setRowCount(0)
             self.results_table.setColumnCount(0)
-            self.row_count_label.setText("No results")
-            return
-
-        # Set dimensions
-        self.results_table.setRowCount(len(df))
-        self.results_table.setColumnCount(len(df.columns))
-        
-        # Set headers
-        self.results_table.setHorizontalHeaderLabels(df.columns)
-        
-        # Populate data
-        for i, (_, row) in enumerate(df.iterrows()):
-            for j, value in enumerate(row):
-                formatted_value = self.format_value(value)
-                item = QTableWidgetItem(formatted_value)
-                
-                # Set alignment based on data type
-                if isinstance(value, (int, float, np.integer, np.floating)):
-                    item.setTextAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
-                else:
-                    item.setTextAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
+            
+            if df.empty:
+                self.statusBar().showMessage("Query returned no results")
+                return
                 
-                # Make cells read-only
-                item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEditable)
+            # Set up the table dimensions
+            row_count = len(df)
+            col_count = len(df.columns)
+            self.results_table.setColumnCount(col_count)
+            
+            # Set column headers
+            headers = [str(col) for col in df.columns]
+            self.results_table.setHorizontalHeaderLabels(headers)
+            
+            # Calculate chunk size (adjust based on available memory)
+            CHUNK_SIZE = 1000
+            
+            # Process data in chunks to avoid memory issues with large datasets
+            for chunk_start in range(0, row_count, CHUNK_SIZE):
+                chunk_end = min(chunk_start + CHUNK_SIZE, row_count)
+                chunk = df.iloc[chunk_start:chunk_end]
                 
-                # Apply special styling for NULL values
-                if pd.isna(value):
-                    item.setForeground(QColor(self.colors['text_light']))
-                    item.setBackground(QColor("#F8F9FA"))
+                # Add rows for this chunk
+                self.results_table.setRowCount(chunk_end)
                 
-                self.results_table.setItem(i, j, item)
-        
-        # Auto-adjust column widths while ensuring minimum and maximum sizes
-        self.results_table.resizeColumnsToContents()
-        for i in range(len(df.columns)):
-            width = self.results_table.columnWidth(i)
-            self.results_table.setColumnWidth(i, min(max(width, 80), 300))
-        
-        # Update row count
-        row_text = "row" if len(df) == 1 else "rows"
-        self.row_count_label.setText(f"{len(df):,} {row_text}")
-        
-        # Apply zebra striping
-        for i in range(len(df)):
-            if i % 2 == 0:
-                for j in range(len(df.columns)):
-                    item = self.results_table.item(i, j)
-                    if item and not pd.isna(df.iloc[i, j]):
-                        item.setBackground(QColor("#FFFFFF"))
-            else:
-                for j in range(len(df.columns)):
-                    item = self.results_table.item(i, j)
-                    if item and not pd.isna(df.iloc[i, j]):
-                        item.setBackground(QColor("#F8F9FA"))
+                for row_idx, (_, row_data) in enumerate(chunk.iterrows(), start=chunk_start):
+                    for col_idx, value in enumerate(row_data):
+                        formatted_value = self.format_value(value)
+                        item = QTableWidgetItem(formatted_value)
+                        self.results_table.setItem(row_idx, col_idx, item)
+                        
+                # Process events to keep UI responsive
+                QApplication.processEvents()
+            
+            # Optimize column widths
+            self.results_table.resizeColumnsToContents()
+            
+            # Restore bar charts for columns that previously had them
+            header = self.results_table.horizontalHeader()
+            if isinstance(header, FilterHeader):
+                for col_idx in columns_with_bars:
+                    if col_idx < col_count:  # Only if column still exists
+                        header.toggle_bar_chart(col_idx)
+            
+            # Update status
+            memory_usage = df.memory_usage(deep=True).sum() / (1024 * 1024)  # Convert to MB
+            self.statusBar().showMessage(
+                f"Loaded {row_count:,} rows, {col_count} columns. Memory usage: {memory_usage:.1f} MB"
+            )
+            
+        except Exception as e:
+            QMessageBox.critical(self, "Error",
+                f"Failed to populate results table:\n\n{str(e)}")
+            self.statusBar().showMessage("Failed to display results")
+
+    def apply_filters(self):
+        """Apply filters to the table based on filter inputs"""
+        if self.current_df is None or not self.filter_widgets:
+            return
+            
+        try:
+            # Start with the original DataFrame
+            filtered_df = self.current_df.copy()
+            
+            # Apply each non-empty filter
+            for col_idx, filter_widget in enumerate(self.filter_widgets):
+                filter_text = filter_widget.text().strip()
+                if filter_text:
+                    col_name = self.current_df.columns[col_idx]
+                    # Convert column to string for filtering
+                    filtered_df[col_name] = filtered_df[col_name].astype(str)
+                    filtered_df = filtered_df[filtered_df[col_name].str.contains(filter_text, case=False, na=False)]
+            
+            # Update table with filtered data
+            row_count = len(filtered_df)
+            for row_idx in range(row_count):
+                for col_idx, value in enumerate(filtered_df.iloc[row_idx]):
+                    formatted_value = self.format_value(value)
+                    item = QTableWidgetItem(formatted_value)
+                    self.results_table.setItem(row_idx, col_idx, item)
+            
+            # Hide rows that don't match filter
+            for row_idx in range(row_count + 1, self.results_table.rowCount()):
+                self.results_table.hideRow(row_idx)
+            
+            # Show all filtered rows
+            for row_idx in range(1, row_count + 1):
+                self.results_table.showRow(row_idx)
+            
+            # Update status
+            self.statusBar().showMessage(f"Showing {row_count:,} rows after filtering")
+            
+        except Exception as e:
+            self.statusBar().showMessage(f"Error applying filters: {str(e)}")
+
+    def format_value(self, value):
+        """Format cell values efficiently"""
+        if pd.isna(value):
+            return "NULL"
+        elif isinstance(value, (float, np.floating)):
+            if value.is_integer():
+                return str(int(value))
+            return f"{value:.6g}"  # Use general format with up to 6 significant digits
+        elif isinstance(value, (pd.Timestamp, datetime)):
+            return value.strftime("%Y-%m-%d %H:%M:%S")
+        elif isinstance(value, (np.integer, int)):
+            return str(value)
+        elif isinstance(value, bool):
+            return str(value)
+        elif isinstance(value, (bytes, bytearray)):
+            return value.hex()
+        return str(value)
 
     def browse_files(self):
         if not self.conn:
             # Create a default in-memory DuckDB connection if none exists
             self.conn = duckdb.connect(':memory:')
-            self.current_db_type = 'duckdb'
+            self.current_connection_type = 'duckdb'
             self.db_info_label.setText("Connected to: in-memory DuckDB")
             
         file_names, _ = QFileDialog.getOpenFileNames(
@@ -999,7 +1077,7 @@ class SQLShell(QMainWindow):
                     counter += 1
                 
                 # Handle table creation based on database type
-                if self.current_db_type == 'sqlite':
+                if self.current_connection_type == 'sqlite':
                     # For SQLite, create a table from the DataFrame
                     df.to_sql(table_name, self.conn, index=False, if_exists='replace')
                 else:
@@ -1066,48 +1144,41 @@ class SQLShell(QMainWindow):
                 self.update_completer()
 
     def open_database(self):
-        """Open a database file (DuckDB or SQLite)"""
-        file_name, _ = QFileDialog.getOpenFileName(
-            self,
-            "Open Database File",
-            "",
-            "Database Files (*.db);;All Files (*)"
-        )
-        
-        if not file_name:
-            return
-            
+        """Open a database connection with proper error handling and resource management"""
         try:
-            # Try to detect database type
-            is_sqlite = self.is_sqlite_db(file_name)
-            
-            # Close existing connection if any
             if self.conn:
-                self.conn.close()
-            
-            # Connect to the database
-            if is_sqlite:
-                self.conn = sqlite3.connect(file_name)
-                self.current_db_type = 'sqlite'
-            else:
-                self.conn = duckdb.connect(file_name)
-                self.current_db_type = 'duckdb'
-            
-            # Clear existing tables
-            self.loaded_tables.clear()
-            self.tables_list.clear()
-            
-            # Load tables
-            self.load_database_tables()
-            
-            # Update UI
-            db_type = "SQLite" if is_sqlite else "DuckDB"
-            self.db_info_label.setText(f"Connected to: {os.path.basename(file_name)} ({db_type})")
-            self.statusBar().showMessage(f'Successfully opened {db_type} database: {file_name}')
+                # Close existing connection before opening new one
+                if self.current_connection_type == "duckdb":
+                    self.conn.close()
+                else:  # sqlite
+                    self.conn.close()
+                self.conn = None
+                self.current_connection_type = None
+            
+            filename, _ = QFileDialog.getOpenFileName(
+                self,
+                "Open Database",
+                "",
+                "All Database Files (*.db *.sqlite *.sqlite3);;All Files (*)"
+            )
             
-        except Exception as e:
-            QMessageBox.critical(self, "Error", f"Failed to open database: {str(e)}")
-            self.statusBar().showMessage('Error opening database')
+            if filename:
+                if self.is_sqlite_db(filename):
+                    self.conn = sqlite3.connect(filename)
+                    self.current_connection_type = "sqlite"
+                else:
+                    self.conn = duckdb.connect(filename)
+                    self.current_connection_type = "duckdb"
+                
+                self.load_database_tables()
+                self.statusBar().showMessage(f"Connected to database: {filename}")
+                
+        except (sqlite3.Error, duckdb.Error) as e:
+            QMessageBox.critical(self, "Database Connection Error",
+                f"Failed to open database:\n\n{str(e)}")
+            self.statusBar().showMessage("Failed to open database")
+            self.conn = None
+            self.current_connection_type = None
 
     def is_sqlite_db(self, filename):
         """Check if the file is a SQLite database"""
@@ -1121,7 +1192,7 @@ class SQLShell(QMainWindow):
     def load_database_tables(self):
         """Load all tables from the current database"""
         try:
-            if self.current_db_type == 'sqlite':
+            if self.current_connection_type == 'sqlite':
                 query = "SELECT name FROM sqlite_master WHERE type='table'"
                 cursor = self.conn.cursor()
                 tables = cursor.execute(query).fetchall()
@@ -1170,60 +1241,44 @@ class SQLShell(QMainWindow):
         self.query_edit.update_completer_model(completion_words)
 
     def execute_query(self):
-        query = self.query_edit.toPlainText().strip()
-        if not query:
-            return
-        
-        if not self.conn:
-            QMessageBox.warning(self, "No Connection", "No database connection available. Creating an in-memory DuckDB database.")
-            self.conn = duckdb.connect(':memory:')
-            self.current_db_type = 'duckdb'
-            self.db_info_label.setText("Connected to: in-memory DuckDB")
-        
-        # Show loading indicator in status bar
-        self.statusBar().showMessage('Executing query...')
-        
         try:
-            # Reset results title
-            results_title = self.findChild(QLabel, "header_label", Qt.FindChildOption.FindChildrenRecursively)
-            if results_title:
-                results_title.setText("RESULTS")
-            
-            if self.current_db_type == 'sqlite':
-                # Execute SQLite query and convert to DataFrame
-                result = pd.read_sql_query(query, self.conn)
-            else:
-                # Execute DuckDB query
-                result = self.conn.execute(query).fetchdf()
-                
-            self.populate_table(result)
-            
-            # Show success message with query stats
-            execution_time = datetime.now().strftime("%H:%M:%S")
-            row_count = len(result)
-            self.statusBar().showMessage(f'Query executed successfully at {execution_time} - {row_count:,} rows returned')
+            query = self.query_edit.toPlainText().strip()
+            if not query:
+                QMessageBox.warning(self, "Empty Query", "Please enter a SQL query to execute.")
+                return
+
+            start_time = datetime.now()
             
-        except Exception as e:
-            self.results_table.setRowCount(0)
-            self.results_table.setColumnCount(0)
-            self.row_count_label.setText("Error")
-            self.statusBar().showMessage('Error executing query')
-            
-            # Show error message with modern styling
-            error_msg = str(e)
-            if "not found" in error_msg.lower():
-                error_msg += "\nMake sure the table name is correct and the table is loaded."
-            elif "syntax error" in error_msg.lower():
-                error_msg += "\nPlease check your SQL syntax."
+            try:
+                if self.current_connection_type == "duckdb":
+                    result = self.conn.execute(query).fetchdf()
+                else:  # sqlite
+                    result = pd.read_sql_query(query, self.conn)
                 
-            error_box = QMessageBox(self)
-            error_box.setIcon(QMessageBox.Icon.Critical)
-            error_box.setWindowTitle("Query Error")
-            error_box.setText("Error executing query")
-            error_box.setInformativeText(error_msg)
-            error_box.setDetailedText(f"Query:\n{query}")
-            error_box.setStandardButtons(QMessageBox.StandardButton.Ok)
-            error_box.exec()
+                execution_time = (datetime.now() - start_time).total_seconds()
+                self.populate_table(result)
+                self.statusBar().showMessage(f"Query executed successfully. Time: {execution_time:.2f}s. Rows: {len(result)}")
+                
+            except (duckdb.Error, sqlite3.Error) as e:
+                error_msg = str(e)
+                if "syntax error" in error_msg.lower():
+                    QMessageBox.critical(self, "SQL Syntax Error", 
+                        f"There is a syntax error in your query:\n\n{error_msg}")
+                elif "no such table" in error_msg.lower():
+                    QMessageBox.critical(self, "Table Not Found", 
+                        f"The referenced table does not exist:\n\n{error_msg}")
+                elif "no such column" in error_msg.lower():
+                    QMessageBox.critical(self, "Column Not Found", 
+                        f"The referenced column does not exist:\n\n{error_msg}")
+                else:
+                    QMessageBox.critical(self, "Database Error", 
+                        f"An error occurred while executing the query:\n\n{error_msg}")
+                self.statusBar().showMessage("Query execution failed")
+                
+        except Exception as e:
+            QMessageBox.critical(self, "Unexpected Error",
+                f"An unexpected error occurred:\n\n{str(e)}")
+            self.statusBar().showMessage("Query execution failed")
 
     def clear_query(self):
         """Clear the query editor with animation"""
@@ -1243,7 +1298,7 @@ class SQLShell(QMainWindow):
         if item:
             table_name = item.text().split(' (')[0]
             try:
-                if self.current_db_type == 'sqlite':
+                if self.current_connection_type == 'sqlite':
                     preview_df = pd.read_sql_query(f'SELECT * FROM "{table_name}" LIMIT 5', self.conn)
                 else:
                     preview_df = self.conn.execute(f'SELECT * FROM {table_name} LIMIT 5').fetchdf()
@@ -1273,6 +1328,12 @@ class SQLShell(QMainWindow):
     def load_test_data(self):
         """Generate and load test data"""
         try:
+            # Ensure we have a DuckDB connection
+            if not self.conn or self.current_connection_type != 'duckdb':
+                self.conn = duckdb.connect(':memory:')
+                self.current_connection_type = 'duckdb'
+                self.db_info_label.setText("Connected to: in-memory DuckDB")
+
             # Show loading indicator
             self.statusBar().showMessage('Generating test data...')
             
@@ -1312,19 +1373,12 @@ class SQLShell(QMainWindow):
             # Set the sample query
             sample_query = """
 SELECT 
-    s.orderid,
-    s.orderdate,
-    c.customername,
-    p.productname,
-    s.quantity,
-    s.unitprice,
-    (s.quantity * s.unitprice) AS total_amount
+    DISTINCT
+    c.customername     
 FROM 
     sample_sales_data s
     INNER JOIN customer_data c ON c.customerid = s.customerid
     INNER JOIN product_catalog p ON p.productid = s.productid
-ORDER BY 
-    s.orderdate DESC
 LIMIT 10
 """
             self.query_edit.setPlainText(sample_query.strip())
@@ -1359,13 +1413,36 @@ LIMIT 10
             df = self.get_table_data_as_dataframe()
             df.to_excel(file_name, index=False)
             
-            self.statusBar().showMessage(f'Data exported to {file_name}')
+            # Generate table name from file name
+            base_name = os.path.splitext(os.path.basename(file_name))[0]
+            table_name = self.sanitize_table_name(base_name)
+            
+            # Ensure unique table name
+            original_name = table_name
+            counter = 1
+            while table_name in self.loaded_tables:
+                table_name = f"{original_name}_{counter}"
+                counter += 1
+            
+            # Register the table in DuckDB
+            self.conn.register(table_name, df)
+            
+            # Update tracking
+            self.loaded_tables[table_name] = file_name
+            self.table_columns[table_name] = df.columns.tolist()
+            
+            # Update UI
+            self.tables_list.addItem(f"{table_name} ({os.path.basename(file_name)})")
+            self.statusBar().showMessage(f'Data exported to {file_name} and loaded as table "{table_name}"')
+            
+            # Update completer with new table and column names
+            self.update_completer()
             
             # Show success message
             QMessageBox.information(
                 self, 
                 "Export Successful", 
-                f"Data has been exported to:\n{file_name}",
+                f"Data has been exported to:\n{file_name}\nand loaded as table: {table_name}",
                 QMessageBox.StandardButton.Ok
             )
         except Exception as e:
@@ -1389,13 +1466,36 @@ LIMIT 10
             df = self.get_table_data_as_dataframe()
             df.to_parquet(file_name, index=False)
             
-            self.statusBar().showMessage(f'Data exported to {file_name}')
+            # Generate table name from file name
+            base_name = os.path.splitext(os.path.basename(file_name))[0]
+            table_name = self.sanitize_table_name(base_name)
+            
+            # Ensure unique table name
+            original_name = table_name
+            counter = 1
+            while table_name in self.loaded_tables:
+                table_name = f"{original_name}_{counter}"
+                counter += 1
+            
+            # Register the table in DuckDB
+            self.conn.register(table_name, df)
+            
+            # Update tracking
+            self.loaded_tables[table_name] = file_name
+            self.table_columns[table_name] = df.columns.tolist()
+            
+            # Update UI
+            self.tables_list.addItem(f"{table_name} ({os.path.basename(file_name)})")
+            self.statusBar().showMessage(f'Data exported to {file_name} and loaded as table "{table_name}"')
+            
+            # Update completer with new table and column names
+            self.update_completer()
             
             # Show success message
             QMessageBox.information(
                 self, 
                 "Export Successful", 
-                f"Data has been exported to:\n{file_name}",
+                f"Data has been exported to:\n{file_name}\nand loaded as table: {table_name}",
                 QMessageBox.StandardButton.Ok
             )
         except Exception as e:
@@ -1428,45 +1528,305 @@ LIMIT 10
         
         super().keyPressEvent(event)
 
+    def closeEvent(self, event):
+        """Ensure proper cleanup of database connections when closing the application"""
+        try:
+            # Check for unsaved changes
+            if self.has_unsaved_changes():
+                reply = QMessageBox.question(self, 'Save Changes',
+                    'Do you want to save your changes before closing?',
+                    QMessageBox.StandardButton.Save | 
+                    QMessageBox.StandardButton.Discard | 
+                    QMessageBox.StandardButton.Cancel)
+                
+                if reply == QMessageBox.StandardButton.Save:
+                    self.save_project()
+                elif reply == QMessageBox.StandardButton.Cancel:
+                    event.ignore()
+                    return
+            
+            # Close database connections
+            if self.conn:
+                if self.current_connection_type == "duckdb":
+                    self.conn.close()
+                else:  # sqlite
+                    self.conn.close()
+            event.accept()
+        except Exception as e:
+            QMessageBox.warning(self, "Cleanup Warning", 
+                f"Warning: Could not properly close database connection:\n{str(e)}")
+            event.accept()
+
+    def has_unsaved_changes(self):
+        """Check if there are unsaved changes in the project"""
+        if not self.current_project_file:
+            return bool(self.loaded_tables or self.query_edit.toPlainText().strip())
+        
+        try:
+            # Load the last saved state
+            with open(self.current_project_file, 'r') as f:
+                saved_data = json.load(f)
+            
+            # Compare current state with saved state
+            current_data = {
+                'tables': {
+                    name: {
+                        'file_path': path,
+                        'columns': self.table_columns.get(name, [])
+                    }
+                    for name, path in self.loaded_tables.items()
+                },
+                'query': self.query_edit.toPlainText(),
+                'connection_type': self.current_connection_type
+            }
+            
+            return current_data != saved_data
+            
+        except Exception:
+            # If there's any error reading the saved file, assume there are unsaved changes
+            return True
+
+    def show_tables_context_menu(self, position):
+        """Show context menu for tables list"""
+        item = self.tables_list.itemAt(position)
+        if not item:
+            return
+
+        # Get table name without the file info in parentheses
+        table_name = item.text().split(' (')[0]
+
+        # Create context menu
+        context_menu = QMenu(self)
+        context_menu.setStyleSheet("""
+            QMenu {
+                background-color: white;
+                border: 1px solid #BDC3C7;
+                padding: 5px;
+            }
+            QMenu::item {
+                padding: 5px 20px;
+            }
+            QMenu::item:selected {
+                background-color: #3498DB;
+                color: white;
+            }
+        """)
+
+        # Add menu actions
+        select_from_action = context_menu.addAction("Select from")
+        add_to_editor_action = context_menu.addAction("Just add to editor")
+
+        # Show menu and get selected action
+        action = context_menu.exec(self.tables_list.mapToGlobal(position))
+
+        if action == select_from_action:
+            # Insert "SELECT * FROM table_name" at cursor position
+            cursor = self.query_edit.textCursor()
+            cursor.insertText(f"SELECT * FROM {table_name}")
+            self.query_edit.setFocus()
+        elif action == add_to_editor_action:
+            # Just insert the table name at cursor position
+            cursor = self.query_edit.textCursor()
+            cursor.insertText(table_name)
+            self.query_edit.setFocus()
+
+    def new_project(self):
+        """Create a new project by clearing current state"""
+        if self.conn:
+            reply = QMessageBox.question(self, 'New Project',
+                                       'Are you sure you want to start a new project? All unsaved changes will be lost.',
+                                       QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+            if reply == QMessageBox.StandardButton.Yes:
+                # Close existing connection
+                if self.current_connection_type == "duckdb":
+                    self.conn.close()
+                else:  # sqlite
+                    self.conn.close()
+                
+                # Reset state
+                self.conn = None
+                self.current_connection_type = None
+                self.loaded_tables.clear()
+                self.table_columns.clear()
+                self.tables_list.clear()
+                self.query_edit.clear()
+                self.results_table.setRowCount(0)
+                self.results_table.setColumnCount(0)
+                self.current_project_file = None
+                self.setWindowTitle('SQL Shell')
+                self.statusBar().showMessage('New project created')
+
+    def save_project(self):
+        """Save the current project"""
+        if not self.current_project_file:
+            self.save_project_as()
+            return
+            
+        self.save_project_to_file(self.current_project_file)
+
+    def save_project_as(self):
+        """Save the current project to a new file"""
+        file_name, _ = QFileDialog.getSaveFileName(
+            self,
+            "Save Project",
+            "",
+            "SQL Shell Project (*.sqls);;All Files (*)"
+        )
+        
+        if file_name:
+            if not file_name.endswith('.sqls'):
+                file_name += '.sqls'
+            self.save_project_to_file(file_name)
+            self.current_project_file = file_name
+            self.setWindowTitle(f'SQL Shell - {os.path.basename(file_name)}')
+
+    def save_project_to_file(self, file_name):
+        """Save project data to a file"""
+        try:
+            project_data = {
+                'tables': {},
+                'query': self.query_edit.toPlainText(),
+                'connection_type': self.current_connection_type
+            }
+            
+            # Save table information
+            for table_name, file_path in self.loaded_tables.items():
+                # For database tables and query results, store the special identifier
+                if file_path in ['database', 'query_result']:
+                    source_path = file_path
+                else:
+                    # For file-based tables, store the absolute path
+                    source_path = os.path.abspath(file_path)
+                
+                project_data['tables'][table_name] = {
+                    'file_path': source_path,
+                    'columns': self.table_columns.get(table_name, [])
+                }
+            
+            with open(file_name, 'w') as f:
+                json.dump(project_data, f, indent=4)
+                
+            self.statusBar().showMessage(f'Project saved to {file_name}')
+            
+        except Exception as e:
+            QMessageBox.critical(self, "Error",
+                f"Failed to save project:\n\n{str(e)}")
+
+    def open_project(self):
+        """Open a project file"""
+        file_name, _ = QFileDialog.getOpenFileName(
+            self,
+            "Open Project",
+            "",
+            "SQL Shell Project (*.sqls);;All Files (*)"
+        )
+        
+        if file_name:
+            try:
+                with open(file_name, 'r') as f:
+                    project_data = json.load(f)
+                
+                # Start fresh
+                self.new_project()
+                
+                # Create connection if needed
+                if not self.conn:
+                    self.conn = duckdb.connect(':memory:')
+                    self.current_connection_type = 'duckdb'
+                    self.db_info_label.setText("Connected to: in-memory DuckDB")
+                
+                # Load tables
+                for table_name, table_info in project_data['tables'].items():
+                    file_path = table_info['file_path']
+                    try:
+                        if file_path == 'database':
+                            # For tables from database, we need to recreate them from their data
+                            # Execute a SELECT to get the data and recreate the table
+                            query = f"SELECT * FROM {table_name}"
+                            df = pd.read_sql_query(query, self.conn)
+                            self.conn.register(table_name, df)
+                            self.loaded_tables[table_name] = 'database'
+                            self.tables_list.addItem(f"{table_name} (database)")
+                        elif file_path == 'query_result':
+                            # For tables from query results, we'll need to re-run the query
+                            # For now, just note it as a query result table
+                            self.loaded_tables[table_name] = 'query_result'
+                            self.tables_list.addItem(f"{table_name} (query result)")
+                        elif os.path.exists(file_path):
+                            # Load the file based on its extension
+                            if file_path.endswith(('.xlsx', '.xls')):
+                                df = pd.read_excel(file_path)
+                            elif file_path.endswith('.csv'):
+                                df = pd.read_csv(file_path)
+                            elif file_path.endswith('.parquet'):
+                                df = pd.read_parquet(file_path)
+                            else:
+                                continue
+                            
+                            # Register the table
+                            self.conn.register(table_name, df)
+                            self.loaded_tables[table_name] = file_path
+                            self.tables_list.addItem(f"{table_name} ({os.path.basename(file_path)})")
+                        else:
+                            QMessageBox.warning(self, "Warning",
+                                f"Could not find file for table {table_name}: {file_path}")
+                            continue
+                            
+                        # Store the columns
+                        self.table_columns[table_name] = table_info['columns']
+                            
+                    except Exception as e:
+                        QMessageBox.warning(self, "Warning",
+                            f"Failed to load table {table_name}:\n{str(e)}")
+                
+                # Restore query
+                if 'query' in project_data:
+                    self.query_edit.setPlainText(project_data['query'])
+                
+                # Update UI
+                self.current_project_file = file_name
+                self.setWindowTitle(f'SQL Shell - {os.path.basename(file_name)}')
+                self.statusBar().showMessage(f'Project loaded from {file_name}')
+                self.update_completer()
+                
+            except Exception as e:
+                QMessageBox.critical(self, "Error",
+                    f"Failed to open project:\n\n{str(e)}")
+
 def main():
     app = QApplication(sys.argv)
+    app.setStyle(QStyleFactory.create('Fusion'))
     
-    # Set application style
-    app.setStyle('Fusion')
+    # Ensure we have a valid working directory with pool.db
+    package_dir = os.path.dirname(os.path.abspath(__file__))
+    working_dir = os.getcwd()
     
-    # Apply custom palette for the entire application
-    palette = QPalette()
-    palette.setColor(QPalette.ColorRole.Window, QColor("#ECF0F1"))
-    palette.setColor(QPalette.ColorRole.WindowText, QColor("#2C3E50"))
-    palette.setColor(QPalette.ColorRole.Base, QColor("#FFFFFF"))
-    palette.setColor(QPalette.ColorRole.AlternateBase, QColor("#F5F5F5"))
-    palette.setColor(QPalette.ColorRole.ToolTipBase, QColor("#2C3E50"))
-    palette.setColor(QPalette.ColorRole.ToolTipText, QColor("#FFFFFF"))
-    palette.setColor(QPalette.ColorRole.Text, QColor("#2C3E50"))
-    palette.setColor(QPalette.ColorRole.Button, QColor("#3498DB"))
-    palette.setColor(QPalette.ColorRole.ButtonText, QColor("#FFFFFF"))
-    palette.setColor(QPalette.ColorRole.BrightText, QColor("#FFFFFF"))
-    palette.setColor(QPalette.ColorRole.Link, QColor("#3498DB"))
-    palette.setColor(QPalette.ColorRole.Highlight, QColor("#3498DB"))
-    palette.setColor(QPalette.ColorRole.HighlightedText, QColor("#FFFFFF"))
-    app.setPalette(palette)
+    # If pool.db doesn't exist in current directory, copy it from package
+    if not os.path.exists(os.path.join(working_dir, 'pool.db')):
+        import shutil
+        package_db = os.path.join(package_dir, 'pool.db')
+        if os.path.exists(package_db):
+            shutil.copy2(package_db, working_dir)
+        else:
+            package_db = os.path.join(os.path.dirname(package_dir), 'pool.db')
+            if os.path.exists(package_db):
+                shutil.copy2(package_db, working_dir)
     
-    # Set default font
-    default_font = QFont("Segoe UI", 10)
-    app.setFont(default_font)
+    # Show splash screen
+    splash = AnimatedSplashScreen()
+    splash.show()
     
-    # Create and show the application
-    sql_shell = SQLShell()
+    # Create and show main window after delay
+    timer = QTimer()
+    window = SQLShell()
+    timer.timeout.connect(lambda: show_main_window())
+    timer.start(2000)  # 2 second delay
     
-    # Set application icon (if available)
-    try:
-        app_icon = QIcon("sqlshell/resources/icon.png")
-        sql_shell.setWindowIcon(app_icon)
-    except:
-        # If icon not found, continue without it
-        pass
+    def show_main_window():
+        window.show()
+        splash.finish(window)
+        timer.stop()
     
-    sql_shell.show()
     sys.exit(app.exec())
 
 if __name__ == '__main__':