sqlshell 0.1.9__py3-none-any.whl → 0.2.1__py3-none-any.whl

sqlshell/main.py

@@ -1,6 +1,9 @@
 import sys
 import os
 import json
+import argparse
+from pathlib import Path
+import tempfile
 
 # Ensure proper path setup for resources when running directly
 if __name__ == "__main__":
@@ -15,7 +18,7 @@ from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout,
                            QCompleter, QFrame, QToolButton, QSizePolicy, QTabWidget,
                            QStyleFactory, QToolBar, QStatusBar, QLineEdit, QMenu,
                            QCheckBox, QWidgetAction, QMenuBar, QInputDialog, QProgressDialog,
-                           QListWidgetItem)
+                           QListWidgetItem, QDialog, QGraphicsDropShadowEffect, QTreeWidgetItem)
 from PyQt6.QtCore import Qt, QAbstractTableModel, QRegularExpression, QRect, QSize, QStringListModel, QPropertyAnimation, QEasingCurve, QTimer, QPoint, QMimeData
 from PyQt6.QtGui import QFont, QColor, QSyntaxHighlighter, QTextCharFormat, QPainter, QTextFormat, QTextCursor, QIcon, QPalette, QLinearGradient, QBrush, QPixmap, QPolygon, QPainterPath, QDrag
 import numpy as np
@@ -28,111 +31,12 @@ from sqlshell.editor import LineNumberArea, SQLEditor
 from sqlshell.ui import FilterHeader, BarChartDelegate
 from sqlshell.db import DatabaseManager
 from sqlshell.query_tab import QueryTab
-
-class DraggableTablesList(QListWidget):
-    """Custom QListWidget that provides better drag functionality for table names."""
-    
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        self.parent = parent
-        self.setDragEnabled(True)
-        self.setDragDropMode(QListWidget.DragDropMode.DragOnly)
-        
-        # Apply custom styling
-        self.setStyleSheet("""
-            QListWidget {
-                background-color: rgba(255, 255, 255, 0.1);
-                border: none;
-                border-radius: 4px;
-                color: white;
-            }
-            QListWidget::item:selected {
-                background-color: rgba(255, 255, 255, 0.2);
-            }
-            QListWidget::item:hover:!selected {
-                background-color: rgba(255, 255, 255, 0.1);
-            }
-        """)
-        
-    def startDrag(self, supportedActions):
-        """Override startDrag to customize the drag data."""
-        item = self.currentItem()
-        if not item:
-            return
-            
-        # Extract the table name without the file info in parentheses
-        table_name = item.text().split(' (')[0]
-        
-        # Create mime data with the table name
-        mime_data = QMimeData()
-        mime_data.setText(table_name)
-        
-        # Create drag object
-        drag = QDrag(self)
-        drag.setMimeData(mime_data)
-        
-        # Create a visually appealing drag pixmap
-        font = self.font()
-        font.setBold(True)
-        metrics = self.fontMetrics()
-        text_width = metrics.horizontalAdvance(table_name)
-        text_height = metrics.height()
-        
-        # Make the pixmap large enough for the text plus padding and a small icon
-        padding = 10
-        pixmap = QPixmap(text_width + padding * 2 + 16, text_height + padding)
-        pixmap.fill(Qt.GlobalColor.transparent)
-        
-        # Begin painting
-        painter = QPainter(pixmap)
-        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
-        
-        # Draw a nice rounded rectangle background
-        bg_color = QColor(44, 62, 80, 220)  # Dark blue with transparency
-        painter.setBrush(QBrush(bg_color))
-        painter.setPen(Qt.PenStyle.NoPen)
-        painter.drawRoundedRect(0, 0, pixmap.width(), pixmap.height(), 5, 5)
-        
-        # Draw text
-        painter.setPen(Qt.GlobalColor.white)
-        painter.setFont(font)
-        painter.drawText(int(padding + 16), int(text_height + (padding / 2) - 2), table_name)
-        
-        # Draw a small database icon (simulated)
-        icon_x = padding / 2
-        icon_y = (pixmap.height() - 12) / 2
-        
-        # Draw a simple database icon as a blue circle with lines
-        table_icon_color = QColor("#3498DB")
-        painter.setBrush(QBrush(table_icon_color))
-        painter.setPen(Qt.GlobalColor.white)
-        painter.drawEllipse(int(icon_x), int(icon_y), 12, 12)
-        
-        # Draw "table" lines inside the circle
-        painter.setPen(Qt.GlobalColor.white)
-        painter.drawLine(int(icon_x + 3), int(icon_y + 4), int(icon_x + 9), int(icon_y + 4))
-        painter.drawLine(int(icon_x + 3), int(icon_y + 6), int(icon_x + 9), int(icon_y + 6))
-        painter.drawLine(int(icon_x + 3), int(icon_y + 8), int(icon_x + 9), int(icon_y + 8))
-        
-        painter.end()
-        
-        # Set the drag pixmap
-        drag.setPixmap(pixmap)
-        
-        # Set hotspot to be at the top-left corner of the text
-        drag.setHotSpot(QPoint(padding, pixmap.height() // 2))
-        
-        # Execute drag operation
-        result = drag.exec(supportedActions)
-        
-        # Optional: add a highlight effect after dragging
-        if result == Qt.DropAction.CopyAction and item:
-            # Briefly highlight the dragged item
-            orig_bg = item.background()
-            item.setBackground(QBrush(QColor(26, 188, 156, 100)))  # Light green highlight
-            
-            # Reset after a short delay
-            QTimer.singleShot(300, lambda: item.setBackground(orig_bg))
+from sqlshell.styles import (get_application_stylesheet, get_tab_corner_stylesheet, 
+                           get_context_menu_stylesheet,
+                           get_header_label_stylesheet, get_db_info_label_stylesheet, 
+                           get_tables_header_stylesheet, get_row_count_label_stylesheet)
+from sqlshell.menus import setup_menubar
+from sqlshell.table_list import DraggableTablesList
 
 class SQLShell(QMainWindow):
     def __init__(self):
@@ -145,9 +49,20 @@ class SQLShell(QMainWindow):
         self.max_recent_projects = 10  # Maximum number of recent projects to track
         self.tabs = []  # Store list of all tabs
         
+        # User preferences
+        self.auto_load_recent_project = True  # Default to auto-loading most recent project
+        
+        # File tracking for quick access
+        self.recent_files = []  # Store list of recently opened files
+        self.frequent_files = {}  # Store file paths with usage counts
+        self.max_recent_files = 15  # Maximum number of recent files to track
+        
         # Load recent projects from settings
         self.load_recent_projects()
         
+        # Load recent and frequent files from settings
+        self.load_recent_files()
+        
         # Define color scheme
         self.colors = {
             'primary': "#2C3E50",       # Dark blue-gray
@@ -169,199 +84,14 @@ class SQLShell(QMainWindow):
         
         # Create initial tab
         self.add_tab()
+        
+        # Load most recent project if enabled and available
+        if self.auto_load_recent_project:
+            self.load_most_recent_project()
 
     def apply_stylesheet(self):
         """Apply custom stylesheet to the application"""
-        self.setStyleSheet(f"""
-            QMainWindow {{
-                background-color: {self.colors['background']};
-            }}
-            
-            QWidget {{
-                color: {self.colors['text']};
-                font-family: 'Segoe UI', 'Arial', sans-serif;
-            }}
-            
-            QLabel {{
-                font-size: 13px;
-                padding: 2px;
-            }}
-            
-            QLabel#header_label {{
-                font-size: 16px;
-                font-weight: bold;
-                color: {self.colors['primary']};
-                padding: 8px 0;
-            }}
-            
-            QPushButton {{
-                background-color: {self.colors['secondary']};
-                color: white;
-                border: none;
-                border-radius: 4px;
-                padding: 8px 16px;
-                font-weight: bold;
-                font-size: 13px;
-                min-height: 30px;
-            }}
-            
-            QPushButton:hover {{
-                background-color: #2980B9;
-            }}
-            
-            QPushButton:pressed {{
-                background-color: #1F618D;
-            }}
-            
-            QPushButton#primary_button {{
-                background-color: {self.colors['accent']};
-            }}
-            
-            QPushButton#primary_button:hover {{
-                background-color: #16A085;
-            }}
-            
-            QPushButton#primary_button:pressed {{
-                background-color: #0E6655;
-            }}
-            
-            QPushButton#danger_button {{
-                background-color: {self.colors['error']};
-            }}
-            
-            QPushButton#danger_button:hover {{
-                background-color: #CB4335;
-            }}
-            
-            QToolButton {{
-                background-color: transparent;
-                border: none;
-                border-radius: 4px;
-                padding: 4px;
-            }}
-            
-            QToolButton:hover {{
-                background-color: rgba(52, 152, 219, 0.2);
-            }}
-            
-            QFrame#sidebar {{
-                background-color: {self.colors['primary']};
-                border-radius: 0px;
-            }}
-            
-            QFrame#content_panel {{
-                background-color: white;
-                border-radius: 8px;
-                border: 1px solid {self.colors['border']};
-            }}
-            
-            QListWidget {{
-                background-color: white;
-                border-radius: 4px;
-                border: 1px solid {self.colors['border']};
-                padding: 4px;
-                outline: none;
-            }}
-            
-            QListWidget::item {{
-                padding: 8px;
-                border-radius: 4px;
-            }}
-            
-            QListWidget::item:selected {{
-                background-color: {self.colors['secondary']};
-                color: white;
-            }}
-            
-            QListWidget::item:hover:!selected {{
-                background-color: #E3F2FD;
-            }}
-            
-            QTableWidget {{
-                background-color: white;
-                alternate-background-color: #F8F9FA;
-                border-radius: 4px;
-                border: 1px solid {self.colors['border']};
-                gridline-color: #E0E0E0;
-                outline: none;
-            }}
-            
-            QTableWidget::item {{
-                padding: 4px;
-            }}
-            
-            QTableWidget::item:selected {{
-                background-color: rgba(52, 152, 219, 0.2);
-                color: {self.colors['text']};
-            }}
-            
-            QHeaderView::section {{
-                background-color: {self.colors['primary']};
-                color: white;
-                padding: 8px;
-                border: none;
-                font-weight: bold;
-            }}
-            
-            QSplitter::handle {{
-                background-color: {self.colors['border']};
-            }}
-            
-            QStatusBar {{
-                background-color: {self.colors['primary']};
-                color: white;
-                padding: 8px;
-            }}
-            
-            QTabWidget::pane {{
-                border: 1px solid {self.colors['border']};
-                border-radius: 4px;
-                top: -1px;
-                background-color: white;
-            }}
-            
-            QTabBar::tab {{
-                background-color: {self.colors['light_bg']};
-                color: {self.colors['text']};
-                border: 1px solid {self.colors['border']};
-                border-bottom: none;
-                border-top-left-radius: 4px;
-                border-top-right-radius: 4px;
-                padding: 8px 12px;
-                margin-right: 2px;
-                min-width: 80px;
-            }}
-            
-            QTabBar::tab:selected {{
-                background-color: white;
-                border-bottom: 1px solid white;
-            }}
-            
-            QTabBar::tab:hover:!selected {{
-                background-color: #E3F2FD;
-            }}
-            
-            QTabBar::close-button {{
-                image: url(close.png);
-                subcontrol-position: right;
-            }}
-            
-            QTabBar::close-button:hover {{
-                background-color: rgba(255, 0, 0, 0.2);
-                border-radius: 2px;
-            }}
-            
-            QPlainTextEdit, QTextEdit {{
-                background-color: white;
-                border-radius: 4px;
-                border: 1px solid {self.colors['border']};
-                padding: 8px;
-                selection-background-color: #BBDEFB;
-                selection-color: {self.colors['text']};
-                font-family: 'Consolas', 'Courier New', monospace;
-                font-size: 14px;
-            }}
-        """)
+        self.setStyleSheet(get_application_stylesheet(self.colors))
 
     def init_ui(self):
         self.setWindowTitle('SQL Shell')
@@ -399,78 +129,12 @@ class SQLShell(QMainWindow):
             if os.path.exists(main_logo_path):
                 self.setWindowIcon(QIcon(main_logo_path))
         
-        # 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)
-        
-        # Add Recent Projects submenu
-        self.recent_projects_menu = file_menu.addMenu('Recent Projects')
-        self.update_recent_projects_menu()
-        
-        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)
-        
-        # Add View menu for window management
-        view_menu = menubar.addMenu('&View')
-        
-        # Maximized window option
-        maximize_action = view_menu.addAction('Maximize Window')
-        maximize_action.setShortcut('F11')
-        maximize_action.triggered.connect(self.toggle_maximize_window)
-        
-        # Zoom submenu
-        zoom_menu = view_menu.addMenu('Zoom')
-        
-        zoom_in_action = zoom_menu.addAction('Zoom In')
-        zoom_in_action.setShortcut('Ctrl++')
-        zoom_in_action.triggered.connect(lambda: self.change_zoom(1.1))
+        # Setup menus
+        setup_menubar(self)
         
-        zoom_out_action = zoom_menu.addAction('Zoom Out')
-        zoom_out_action.setShortcut('Ctrl+-')
-        zoom_out_action.triggered.connect(lambda: self.change_zoom(0.9))
-        
-        reset_zoom_action = zoom_menu.addAction('Reset Zoom')
-        reset_zoom_action.setShortcut('Ctrl+0')
-        reset_zoom_action.triggered.connect(lambda: self.reset_zoom())
-        
-        # Add Tab menu
-        tab_menu = menubar.addMenu('&Tab')
-        
-        new_tab_action = tab_menu.addAction('New Tab')
-        new_tab_action.setShortcut('Ctrl+T')
-        new_tab_action.triggered.connect(self.add_tab)
-        
-        duplicate_tab_action = tab_menu.addAction('Duplicate Current Tab')
-        duplicate_tab_action.setShortcut('Ctrl+D')
-        duplicate_tab_action.triggered.connect(self.duplicate_current_tab)
-        
-        rename_tab_action = tab_menu.addAction('Rename Current Tab')
-        rename_tab_action.setShortcut('Ctrl+R')
-        rename_tab_action.triggered.connect(self.rename_current_tab)
-        
-        close_tab_action = tab_menu.addAction('Close Current Tab')
-        close_tab_action.setShortcut('Ctrl+W')
-        close_tab_action.triggered.connect(self.close_current_tab)
+        # Update quick access menu
+        if hasattr(self, 'quick_access_menu'):
+            self.update_quick_access_menu()
         
         # Create custom status bar
         status_bar = QStatusBar()
@@ -495,53 +159,37 @@ class SQLShell(QMainWindow):
         # Database info section
         db_header = QLabel("DATABASE")
         db_header.setObjectName("header_label")
-        db_header.setStyleSheet("color: white;")
+        db_header.setStyleSheet(get_header_label_stylesheet())
         left_layout.addWidget(db_header)
         
         self.db_info_label = QLabel("No database connected")
-        self.db_info_label.setStyleSheet("color: white; background-color: rgba(255, 255, 255, 0.1); padding: 8px; border-radius: 4px;")
+        self.db_info_label.setStyleSheet(get_db_info_label_stylesheet())
         left_layout.addWidget(self.db_info_label)
         
         # Database action buttons
         db_buttons_layout = QHBoxLayout()
         db_buttons_layout.setSpacing(8)
         
-        self.open_db_btn = QPushButton('Open Database')
-        self.open_db_btn.setIcon(QIcon.fromTheme("document-open"))
-        self.open_db_btn.clicked.connect(self.open_database)
+        self.load_btn = QPushButton('Load')
+        self.load_btn.setIcon(QIcon.fromTheme("document-open"))
+        self.load_btn.clicked.connect(self.show_load_dialog)
         
-        self.test_btn = QPushButton('Load Test Data')
-        self.test_btn.clicked.connect(self.load_test_data)
+        self.quick_access_btn = QPushButton('Quick Access')
+        self.quick_access_btn.setIcon(QIcon.fromTheme("document-open-recent"))
+        self.quick_access_btn.clicked.connect(self.show_quick_access_menu)
         
-        db_buttons_layout.addWidget(self.open_db_btn)
-        db_buttons_layout.addWidget(self.test_btn)
+        db_buttons_layout.addWidget(self.load_btn)
+        db_buttons_layout.addWidget(self.quick_access_btn)
         left_layout.addLayout(db_buttons_layout)
         
         # Tables section
         tables_header = QLabel("TABLES")
         tables_header.setObjectName("header_label")
-        tables_header.setStyleSheet("color: white; margin-top: 16px;")
+        tables_header.setStyleSheet(get_tables_header_stylesheet())
         left_layout.addWidget(tables_header)
         
-        # Table actions
-        table_actions_layout = QHBoxLayout()
-        table_actions_layout.setSpacing(8)
-        
-        self.browse_btn = QPushButton('Load Files')
-        self.browse_btn.setIcon(QIcon.fromTheme("document-new"))
-        self.browse_btn.clicked.connect(self.browse_files)
-        
-        self.remove_table_btn = QPushButton('Remove')
-        self.remove_table_btn.setObjectName("danger_button")
-        self.remove_table_btn.setIcon(QIcon.fromTheme("edit-delete"))
-        self.remove_table_btn.clicked.connect(self.remove_selected_table)
-        
-        table_actions_layout.addWidget(self.browse_btn)
-        table_actions_layout.addWidget(self.remove_table_btn)
-        left_layout.addLayout(table_actions_layout)
-        
         # Tables list with custom styling
-        self.tables_list = DraggableTablesList()
+        self.tables_list = DraggableTablesList(self)
         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)
@@ -581,7 +229,7 @@ class SQLShell(QMainWindow):
         main_layout.addWidget(right_panel, 4)
 
         # Status bar
-        self.statusBar().showMessage('Ready | Ctrl+Enter: Execute Query | Ctrl+K: Toggle Comment | Ctrl+T: New Tab')
+        self.statusBar().showMessage('Ready | Ctrl+Enter: Execute Query | Ctrl+K: Toggle Comment | Ctrl+T: New Tab | Ctrl+Shift+O: Quick Access Files')
         
     def create_tab_corner_widget(self):
         """Create a corner widget with a + button to add new tabs"""
@@ -593,23 +241,7 @@ class SQLShell(QMainWindow):
         add_tab_btn = QToolButton()
         add_tab_btn.setText("+")
         add_tab_btn.setToolTip("Add new tab (Ctrl+T)")
-        add_tab_btn.setStyleSheet("""
-            QToolButton {
-                background-color: transparent;
-                border: none;
-                border-radius: 4px;
-                padding: 4px;
-                font-weight: bold;
-                font-size: 16px;
-                color: #3498DB;
-            }
-            QToolButton:hover {
-                background-color: rgba(52, 152, 219, 0.2);
-            }
-            QToolButton:pressed {
-                background-color: rgba(52, 152, 219, 0.4);
-            }
-        """)
+        add_tab_btn.setStyleSheet(get_tab_corner_stylesheet())
         add_tab_btn.clicked.connect(self.add_tab)
         
         layout.addWidget(add_tab_btn)
@@ -743,11 +375,16 @@ class SQLShell(QMainWindow):
         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
+            # Display full number without scientific notation by using 'f' format
+            # Format large numbers with commas for better readability
+            if abs(value) >= 1000000:
+                return f"{value:,.2f}"  # Format with commas and 2 decimal places
+            return f"{value:.6f}"  # Use fixed-point notation with 6 decimal places
         elif isinstance(value, (pd.Timestamp, datetime)):
             return value.strftime("%Y-%m-%d %H:%M:%S")
         elif isinstance(value, (np.integer, int)):
-            return str(value)
+            # Format large integers with commas for better readability
+            return f"{value:,}"
         elif isinstance(value, bool):
             return str(value)
         elif isinstance(value, (bytes, bytearray)):
@@ -769,11 +406,14 @@ class SQLShell(QMainWindow):
         
         for file_name in file_names:
             try:
+                # Add to recent files
+                self.add_recent_file(file_name)
+                
                 # Use the database manager to load the file
                 table_name, df = self.db_manager.load_file(file_name)
                 
-                # Update UI
-                self.tables_list.addItem(f"{table_name} ({os.path.basename(file_name)})")
+                # Update UI using new method
+                self.tables_list.add_table_item(table_name, os.path.basename(file_name))
                 self.statusBar().showMessage(f'Loaded {file_name} as table "{table_name}"')
                 
                 # Show preview of loaded data
@@ -798,18 +438,34 @@ class SQLShell(QMainWindow):
 
     def remove_selected_table(self):
         current_item = self.tables_list.currentItem()
-        if current_item:
-            table_name = current_item.text().split(' (')[0]
-            if self.db_manager.remove_table(table_name):
-                # Remove from list widget
-                self.tables_list.takeItem(self.tables_list.row(current_item))
-                self.statusBar().showMessage(f'Removed table "{table_name}"')
-                self.results_table.setRowCount(0)
-                self.results_table.setColumnCount(0)
-                self.row_count_label.setText("")
-                
-                # Update completer
-                self.update_completer()
+        if not current_item or self.tables_list.is_folder_item(current_item):
+            return
+            
+        table_name = self.tables_list.get_table_name_from_item(current_item)
+        if not table_name:
+            return
+            
+        if self.db_manager.remove_table(table_name):
+            # Remove from tree widget
+            parent = current_item.parent()
+            if parent:
+                parent.removeChild(current_item)
+            else:
+                index = self.tables_list.indexOfTopLevelItem(current_item)
+                if index >= 0:
+                    self.tables_list.takeTopLevelItem(index)
+                    
+            self.statusBar().showMessage(f'Removed table "{table_name}"')
+            
+            # Get the current tab and clear its results table
+            current_tab = self.get_current_tab()
+            if current_tab:
+                current_tab.results_table.setRowCount(0)
+                current_tab.results_table.setColumnCount(0)
+                current_tab.row_count_label.setText("")
+            
+            # Update completer
+            self.update_completer()
 
     def open_database(self):
         """Open a database connection with proper error handling and resource management"""
@@ -823,19 +479,22 @@ class SQLShell(QMainWindow):
             
             if filename:
                 try:
+                    # Add to recent files
+                    self.add_recent_file(filename)
+                    
                     # Clear existing database tables from the list widget
-                    for i in range(self.tables_list.count() - 1, -1, -1):
-                        item = self.tables_list.item(i)
-                        if item and item.text().endswith('(database)'):
-                            self.tables_list.takeItem(i)
+                    for i in range(self.tables_list.topLevelItemCount() - 1, -1, -1):
+                        item = self.tables_list.topLevelItem(i)
+                        if item and item.text(0).endswith('(database)'):
+                            self.tables_list.takeTopLevelItem(i)
                     
                     # Use the database manager to open the database
-                    self.db_manager.open_database(filename)
+                    self.db_manager.open_database(filename, load_all_tables=True)
                     
                     # Update UI with tables from the database
                     for table_name, source in self.db_manager.loaded_tables.items():
                         if source == 'database':
-                            self.tables_list.addItem(f"{table_name} (database)")
+                            self.tables_list.add_table_item(table_name, "database")
                     
                     # Update the completer with table and column names
                     self.update_completer()
@@ -861,6 +520,12 @@ class SQLShell(QMainWindow):
             if self.tab_widget.count() == 0:
                 return
             
+            # Import the suggestion manager
+            from sqlshell.suggester_integration import get_suggestion_manager
+            
+            # Get the suggestion manager singleton
+            suggestion_mgr = get_suggestion_manager()
+            
             # Start a background update with a timer
             self.statusBar().showMessage("Updating auto-completion...", 2000)
             
@@ -869,7 +534,34 @@ class SQLShell(QMainWindow):
                 self.query_history = []
                 self.completion_usage = {}  # Track usage frequency
             
-            # Get completion words from the database manager
+            # Get schema information from the database manager
+            try:
+                # Get table and column information
+                tables = set(self.db_manager.loaded_tables.keys())
+                table_columns = self.db_manager.table_columns
+                
+                # Get column data types if available
+                column_types = {}
+                for table, columns in self.db_manager.table_columns.items():
+                    for col in columns:
+                        qualified_name = f"{table}.{col}"
+                        # Try to infer type from sample data
+                        if hasattr(self.db_manager, 'sample_data') and table in self.db_manager.sample_data:
+                            sample = self.db_manager.sample_data[table]
+                            if col in sample.columns:
+                                # Get data type from pandas
+                                col_dtype = str(sample[col].dtype)
+                                column_types[qualified_name] = col_dtype
+                                # Also store unqualified name
+                                column_types[col] = col_dtype
+                
+                # Update the suggestion manager with schema information
+                suggestion_mgr.update_schema(tables, table_columns, column_types)
+                
+            except Exception as e:
+                self.statusBar().showMessage(f"Error getting completions: {str(e)}", 2000)
+            
+            # Get all completion words from basic system (for backward compatibility)
             try:
                 completion_words = self.db_manager.get_all_table_columns()
             except Exception as e:
@@ -886,141 +578,45 @@ class SQLShell(QMainWindow):
                 )[:100]
                 
                 # Add these to our completion words
-                for term, _ in frequent_terms:
+                for term, count in frequent_terms:
+                    suggestion_mgr.suggester.usage_counts[term] = count
                     if term not in completion_words:
                         completion_words.append(term)
             
-            # Limit to a reasonable number of items to prevent performance issues
-            MAX_COMPLETION_ITEMS = 2000  # Increased from 1000 to accommodate more smart suggestions
-            if len(completion_words) > MAX_COMPLETION_ITEMS:
-                # Create a more advanced prioritization strategy
-                prioritized_words = []
-                
-                # First, include all table names
-                tables = list(self.db_manager.loaded_tables.keys())
-                prioritized_words.extend(tables)
-                
-                # Then add most common SQL keywords and patterns
-                sql_keywords = [w for w in completion_words if w.isupper() and len(w) > 1]
-                prioritized_words.extend(sql_keywords[:200])  # Cap at 200 keywords
-                
-                # Add frequently used items
-                if hasattr(self, 'completion_usage'):
-                    frequent_items = [
-                        item for item, _ in sorted(
-                            self.completion_usage.items(), 
-                            key=lambda x: x[1], 
-                            reverse=True
-                        )[:100]  # Top 100 most used
-                    ]
-                    prioritized_words.extend(frequent_items)
-                
-                # Add table.column patterns which are very useful
-                qualified_columns = [w for w in completion_words if '.' in w and w.split('.')[0] in tables]
-                prioritized_words.extend(qualified_columns[:300])  # Cap at 300 qualified columns
-                
-                # Add common completion patterns
-                patterns = [w for w in completion_words if ' ' in w]  # Spaces indicate phrases/patterns
-                prioritized_words.extend(patterns[:200])  # Cap at 200 patterns
-                
-                # Finally add other columns
-                remaining_slots = MAX_COMPLETION_ITEMS - len(prioritized_words)
-                remaining_words = [
-                    w for w in completion_words 
-                    if w not in prioritized_words 
-                    and not w.isupper() 
-                    and '.' not in w 
-                    and ' ' not in w
-                ]
-                prioritized_words.extend(remaining_words[:remaining_slots])
-                
-                # Remove duplicates while preserving order
-                seen = set()
-                completion_words = []
-                for item in prioritized_words:
-                    if item not in seen:
-                        seen.add(item)
-                        completion_words.append(item)
-                
-                # Ensure we don't exceed the maximum
-                completion_words = completion_words[:MAX_COMPLETION_ITEMS]
-            
-            # Use a single model for all tabs to save memory and improve performance
+            # Create a single shared model for all tabs to save memory
             model = QStringListModel(completion_words)
             
             # Keep a reference to the model to prevent garbage collection
             self._current_completer_model = model
             
-            # Only update the current tab immediately
-            current_index = self.tab_widget.currentIndex()
-            if current_index >= 0:
-                current_tab = self.tab_widget.widget(current_index)
-                if current_tab and hasattr(current_tab, 'query_edit'):
+            # First unregister all existing editors to avoid duplicates
+            existing_editors = suggestion_mgr._editors.copy()
+            for editor_id in existing_editors:
+                suggestion_mgr.unregister_editor(editor_id)
+            
+            # Register editors with the suggestion manager and update their completer models
+            for i in range(self.tab_widget.count()):
+                tab = self.tab_widget.widget(i)
+                if tab and hasattr(tab, 'query_edit'):
+                    # Register this editor with the suggestion manager using a unique ID
+                    editor_id = f"tab_{i}_{id(tab.query_edit)}"
+                    suggestion_mgr.register_editor(tab.query_edit, editor_id)
+                    
+                    # Update the basic completer model for backward compatibility
                     try:
-                        current_tab.query_edit.update_completer_model(model)
+                        tab.query_edit.update_completer_model(model)
                     except Exception as e:
-                        self.statusBar().showMessage(f"Error updating current tab completer: {str(e)}", 2000)
-            
-            # Only schedule updates for additional tabs if we have more than 3 tabs
-            # This reduces overhead for common usage patterns
-            if self.tab_widget.count() > 1:
-                # Calculate a reasonable maximum delay (ms)
-                max_delay = min(500, 50 * self.tab_widget.count())
-                
-                # Store timers to prevent garbage collection
-                if not hasattr(self, '_completer_timers'):
-                    self._completer_timers = []
-                
-                # Clear old timers
-                for timer in self._completer_timers:
-                    if timer.isActive():
-                        timer.stop()
-                self._completer_timers = []
-                
-                # Schedule updates for other tabs with increasing delays
-                for i in range(self.tab_widget.count()):
-                    if i != current_index:
-                        tab = self.tab_widget.widget(i)
-                        if tab and not tab.isHidden() and hasattr(tab, 'query_edit'):
-                            delay = int((i + 1) / self.tab_widget.count() * max_delay)
-                            
-                            timer = QTimer()
-                            timer.setSingleShot(True)
-                            # Store tab and model as local variables for the lambda
-                            # to avoid closure issues
-                            tab_ref = tab
-                            model_ref = model
-                            timer.timeout.connect(
-                                lambda t=tab_ref, m=model_ref: self._update_tab_completer(t, m))
-                            self._completer_timers.append(timer)
-                            timer.start(delay)
+                        self.statusBar().showMessage(f"Error updating completer for tab {i}: {str(e)}", 2000)
             
             # Process events to keep UI responsive
             QApplication.processEvents()
             
-            # Return True to indicate success
             return True
             
         except Exception as e:
             # Catch any errors to prevent hanging
             self.statusBar().showMessage(f"Auto-completion update error: {str(e)}", 2000)
             return False
-            
-    def _update_tab_completer(self, tab, model):
-        """Helper method to update a tab's completer with the given model"""
-        if tab and not tab.isHidden() and hasattr(tab, 'query_edit'):  # Only update visible tabs with query editors
-            try:
-                tab.query_edit.update_completer_model(model)
-                QApplication.processEvents()  # Keep UI responsive
-            except Exception as e:
-                print(f"Error updating tab completer: {e}")
-                # Try a simpler approach as fallback
-                try:
-                    if hasattr(tab.query_edit, 'all_sql_keywords'):
-                        fallback_model = QStringListModel(tab.query_edit.all_sql_keywords)
-                        tab.query_edit.completer.setModel(fallback_model)
-                except Exception:
-                    pass  # Last resort: ignore errors to prevent crashes
 
     def execute_query(self):
         try:
@@ -1044,7 +640,16 @@ class SQLShell(QMainWindow):
                 self.populate_table(result)
                 self.statusBar().showMessage(f"Query executed successfully. Time: {execution_time:.2f}s. Rows: {len(result)}")
                 
-                # Record query in history and update completion usage
+                # Record query for context-aware suggestions
+                try:
+                    from sqlshell.suggester_integration import get_suggestion_manager
+                    suggestion_mgr = get_suggestion_manager()
+                    suggestion_mgr.record_query(query)
+                except Exception as e:
+                    # Don't let suggestion errors affect query execution
+                    print(f"Error recording query for suggestions: {e}")
+                
+                # Record query in history and update completion usage (legacy)
                 self._update_query_history(query)
                 
             except SyntaxError as e:
@@ -1145,7 +750,7 @@ class SQLShell(QMainWindow):
 
     def show_table_preview(self, item):
         """Show a preview of the selected table"""
-        if not item:
+        if not item or self.tables_list.is_folder_item(item):
             return
             
         # Get the current tab
@@ -1153,7 +758,15 @@ class SQLShell(QMainWindow):
         if not current_tab:
             return
             
-        table_name = item.text().split(' (')[0]
+        table_name = self.tables_list.get_table_name_from_item(item)
+        if not table_name:
+            return
+        
+        # Check if this table needs to be reloaded first
+        if table_name in self.tables_list.tables_needing_reload:
+            # Reload the table immediately without asking
+            self.reload_selected_table(table_name)
+                
         try:
             # Use the database manager to get a preview of the table
             preview_df = self.db_manager.get_table_preview(table_name)
@@ -1189,40 +802,59 @@ class SQLShell(QMainWindow):
             # Show loading indicator
             self.statusBar().showMessage('Generating test data...')
             
-            # Create test data directory if it doesn't exist
-            os.makedirs('test_data', exist_ok=True)
+            # Create temporary directory for test data
+            temp_dir = tempfile.mkdtemp(prefix='sqlshell_test_')
             
             # Generate test data
             sales_df = create_test_data.create_sales_data()
             customer_df = create_test_data.create_customer_data()
             product_df = create_test_data.create_product_data()
+            large_numbers_df = create_test_data.create_large_numbers_data()
             
-            # Save test data
-            sales_df.to_excel('test_data/sample_sales_data.xlsx', index=False)
-            customer_df.to_parquet('test_data/customer_data.parquet', index=False)
-            product_df.to_excel('test_data/product_catalog.xlsx', index=False)
+            # Save test data to temporary directory
+            sales_path = os.path.join(temp_dir, 'sample_sales_data.xlsx')
+            customer_path = os.path.join(temp_dir, 'customer_data.parquet')
+            product_path = os.path.join(temp_dir, 'product_catalog.xlsx')
+            large_numbers_path = os.path.join(temp_dir, 'large_numbers.xlsx')
+            
+            sales_df.to_excel(sales_path, index=False)
+            customer_df.to_parquet(customer_path, index=False)
+            product_df.to_excel(product_path, index=False)
+            large_numbers_df.to_excel(large_numbers_path, index=False)
             
             # Register the tables in the database manager
-            self.db_manager.register_dataframe(sales_df, 'sample_sales_data', 'test_data/sample_sales_data.xlsx')
-            self.db_manager.register_dataframe(product_df, 'product_catalog', 'test_data/product_catalog.xlsx')
-            self.db_manager.register_dataframe(customer_df, 'customer_data', 'test_data/customer_data.parquet')
+            self.db_manager.register_dataframe(sales_df, 'sample_sales_data', sales_path)
+            self.db_manager.register_dataframe(product_df, 'product_catalog', product_path)
+            self.db_manager.register_dataframe(customer_df, 'customer_data', customer_path)
+            self.db_manager.register_dataframe(large_numbers_df, 'large_numbers', large_numbers_path)
             
             # Update UI
             self.tables_list.clear()
             for table_name, file_path in self.db_manager.loaded_tables.items():
-                self.tables_list.addItem(f"{table_name} ({os.path.basename(file_path)})")
+                # Use the new add_table_item method
+                self.tables_list.add_table_item(table_name, os.path.basename(file_path))
             
             # Set the sample query in the current tab
             current_tab = self.get_current_tab()
             if current_tab:
                 sample_query = """
+-- Example query with tables containing large numbers
 SELECT 
-    DISTINCT
-    c.customername     
+    ln.ID,
+    ln.Category,
+    ln.MediumValue,
+    ln.LargeValue,
+    ln.VeryLargeValue,
+    ln.MassiveValue,
+    ln.ExponentialValue,
+    ln.Revenue,
+    ln.Budget
 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
+    large_numbers ln
+WHERE 
+    ln.LargeValue > 5000000000000
+ORDER BY 
+    ln.MassiveValue DESC
 LIMIT 10
 """
                 current_tab.set_query_text(sample_query.strip())
@@ -1233,8 +865,10 @@ LIMIT 10
             # Show success message
             self.statusBar().showMessage('Test data loaded successfully')
             
-            # Show a preview of the sales data
-            self.show_table_preview(self.tables_list.item(0))
+            # Show a preview of the large numbers data
+            large_numbers_item = self.tables_list.find_table_item("large_numbers")
+            if large_numbers_item:
+                self.show_table_preview(large_numbers_item)
             
         except Exception as e:
             self.statusBar().showMessage(f'Error loading test data: {str(e)}')
@@ -1280,8 +914,8 @@ LIMIT 10
             self.db_manager.loaded_tables[table_name] = file_name
             self.db_manager.table_columns[table_name] = df.columns.tolist()
             
-            # Update UI
-            self.tables_list.addItem(f"{table_name} ({os.path.basename(file_name)})")
+            # Update UI using new method
+            self.tables_list.add_table_item(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
@@ -1338,8 +972,8 @@ LIMIT 10
             self.db_manager.loaded_tables[table_name] = file_name
             self.db_manager.table_columns[table_name] = df.columns.tolist()
             
-            # Update UI
-            self.tables_list.addItem(f"{table_name} ({os.path.basename(file_name)})")
+            # Update UI using new method
+            self.tables_list.add_table_item(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
@@ -1357,7 +991,7 @@ LIMIT 10
             self.statusBar().showMessage('Error exporting data')
 
     def get_table_data_as_dataframe(self):
-        """Helper function to convert table widget data to a DataFrame"""
+        """Helper function to convert table widget data to a DataFrame with proper data types"""
         # Get the current tab
         current_tab = self.get_current_tab()
         if not current_tab:
@@ -1371,7 +1005,81 @@ LIMIT 10
                 item = current_tab.results_table.item(row, column)
                 row_data.append(item.text() if item else '')
             data.append(row_data)
-        return pd.DataFrame(data, columns=headers)
+        
+        # Create DataFrame from raw string data
+        df_raw = pd.DataFrame(data, columns=headers)
+        
+        # Try to use the original dataframe's dtypes if available
+        if hasattr(current_tab, 'current_df') and current_tab.current_df is not None:
+            original_df = current_tab.current_df
+            # Since we might have filtered rows, we can't just return the original DataFrame
+            # But we can use its column types to convert our string data appropriately
+            
+            # Create a new DataFrame with appropriate types
+            df_typed = pd.DataFrame()
+            
+            for col in df_raw.columns:
+                if col in original_df.columns:
+                    # Get the original column type
+                    orig_type = original_df[col].dtype
+                    
+                    # Special handling for different data types
+                    if pd.api.types.is_numeric_dtype(orig_type):
+                        # Handle numeric columns (int or float)
+                        try:
+                            # First try to convert to numeric type
+                            # Remove commas used for thousands separators
+                            numeric_col = pd.to_numeric(df_raw[col].str.replace(',', '').replace('NULL', np.nan))
+                            df_typed[col] = numeric_col
+                        except:
+                            # If that fails, keep the original string
+                            df_typed[col] = df_raw[col]
+                    elif pd.api.types.is_datetime64_dtype(orig_type):
+                        # Handle datetime columns
+                        try:
+                            df_typed[col] = pd.to_datetime(df_raw[col].replace('NULL', np.nan))
+                        except:
+                            df_typed[col] = df_raw[col]
+                    elif pd.api.types.is_bool_dtype(orig_type):
+                        # Handle boolean columns
+                        try:
+                            df_typed[col] = df_raw[col].map({'True': True, 'False': False}).replace('NULL', np.nan)
+                        except:
+                            df_typed[col] = df_raw[col]
+                    else:
+                        # For other types, keep as is
+                        df_typed[col] = df_raw[col]
+                else:
+                    # For columns not in the original dataframe, infer type
+                    df_typed[col] = df_raw[col]
+                    
+            return df_typed
+            
+        else:
+            # If we don't have the original dataframe, try to infer types
+            # First replace 'NULL' with actual NaN
+            df_raw.replace('NULL', np.nan, inplace=True)
+            
+            # Try to convert each column to numeric if possible
+            for col in df_raw.columns:
+                try:
+                    # First try to convert to numeric by removing commas
+                    df_raw[col] = pd.to_numeric(df_raw[col].str.replace(',', ''))
+                except:
+                    # If that fails, try to convert to datetime
+                    try:
+                        df_raw[col] = pd.to_datetime(df_raw[col])
+                    except:
+                        # If both numeric and datetime conversions fail,
+                        # try boolean conversion for True/False strings
+                        try:
+                            if df_raw[col].dropna().isin(['True', 'False']).all():
+                                df_raw[col] = df_raw[col].map({'True': True, 'False': False})
+                        except:
+                            # Otherwise, keep as is
+                            pass
+            
+            return df_raw
 
     def keyPressEvent(self, event):
         """Handle global keyboard shortcuts"""
@@ -1400,6 +1108,13 @@ LIMIT 10
             self.rename_current_tab()
             return
         
+        # Show quick access menu with Ctrl+Shift+O
+        if (event.key() == Qt.Key.Key_O and 
+            (event.modifiers() & Qt.KeyboardModifier.ControlModifier) and 
+            (event.modifiers() & Qt.KeyboardModifier.ShiftModifier)):
+            self.show_quick_access_menu()
+            return
+        
         super().keyPressEvent(event)
 
     def closeEvent(self, event):
@@ -1489,7 +1204,9 @@ LIMIT 10
     def show_tables_context_menu(self, position):
         """Show context menu for tables list"""
         item = self.tables_list.itemAt(position)
-        if not item:
+        
+        # If no item or it's a folder, let the tree widget handle it
+        if not item or self.tables_list.is_folder_item(item):
             return
 
         # Get current tab
@@ -1498,28 +1215,54 @@ LIMIT 10
             return
 
         # Get table name without the file info in parentheses
-        table_name = item.text().split(' (')[0]
+        table_name = self.tables_list.get_table_name_from_item(item)
+        if not table_name:
+            return
 
         # 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;
-            }
-        """)
+        context_menu.setStyleSheet(get_context_menu_stylesheet())
 
         # Add menu actions
         select_from_action = context_menu.addAction("Select from")
         add_to_editor_action = context_menu.addAction("Just add to editor")
+        
+        # Add entropy profiler action
+        context_menu.addSeparator()
+        analyze_entropy_action = context_menu.addAction("Analyze Column Importance")
+        analyze_entropy_action.setIcon(QIcon.fromTheme("system-search"))
+        
+        # Add table profiler action
+        profile_table_action = context_menu.addAction("Profile Table Structure")
+        profile_table_action.setIcon(QIcon.fromTheme("edit-find"))
+        
+        # Check if table needs reloading and add appropriate action
+        if table_name in self.tables_list.tables_needing_reload:
+            reload_action = context_menu.addAction("Reload Table")
+            reload_action.setIcon(QIcon.fromTheme("view-refresh"))
+        else:
+            reload_action = context_menu.addAction("Refresh")
+            reload_action.setIcon(QIcon.fromTheme("view-refresh"))
+        
+        # Add move to folder submenu
+        move_menu = context_menu.addMenu("Move to Folder")
+        move_menu.setIcon(QIcon.fromTheme("folder"))
+        
+        # Add "New Folder" option to move menu
+        new_folder_action = move_menu.addAction("New Folder...")
+        move_menu.addSeparator()
+        
+        # Add folders to the move menu
+        for i in range(self.tables_list.topLevelItemCount()):
+            top_item = self.tables_list.topLevelItem(i)
+            if self.tables_list.is_folder_item(top_item):
+                folder_action = move_menu.addAction(top_item.text(0))
+                folder_action.setData(top_item)
+        
+        # Add root option
+        move_menu.addSeparator()
+        root_action = move_menu.addAction("Root (No Folder)")
+        
         context_menu.addSeparator()
         rename_action = context_menu.addAction("Rename table...")
         delete_action = context_menu.addAction("Delete table")
@@ -1529,6 +1272,11 @@ LIMIT 10
         action = context_menu.exec(self.tables_list.mapToGlobal(position))
 
         if action == select_from_action:
+            # Check if table needs reloading first
+            if table_name in self.tables_list.tables_needing_reload:
+                # Reload the table immediately without asking
+                self.reload_selected_table(table_name)
+                    
             # Insert "SELECT * FROM table_name" at cursor position
             cursor = current_tab.query_edit.textCursor()
             cursor.insertText(f"SELECT * FROM {table_name}")
@@ -1538,6 +1286,14 @@ LIMIT 10
             cursor = current_tab.query_edit.textCursor()
             cursor.insertText(table_name)
             current_tab.query_edit.setFocus()
+        elif action == reload_action:
+            self.reload_selected_table(table_name)
+        elif action == analyze_entropy_action:
+            # Call the entropy analysis method
+            self.analyze_table_entropy(table_name)
+        elif action == profile_table_action:
+            # Call the table profile method
+            self.profile_table_structure(table_name)
         elif action == rename_action:
             # Show rename dialog
             new_name, ok = QInputDialog.getText(
@@ -1550,8 +1306,8 @@ LIMIT 10
             if ok and new_name:
                 if self.rename_table(table_name, new_name):
                     # Update the item text
-                    source = item.text().split(' (')[1][:-1]  # Get the source part
-                    item.setText(f"{new_name} ({source})")
+                    source = item.text(0).split(' (')[1][:-1]  # Get the source part
+                    item.setText(0, f"{new_name} ({source})")
                     self.statusBar().showMessage(f'Table renamed to "{new_name}"')
         elif action == delete_action:
             # Show confirmation dialog
@@ -1563,17 +1319,91 @@ LIMIT 10
             )
             if reply == QMessageBox.StandardButton.Yes:
                 self.remove_selected_table()
+        elif action == new_folder_action:
+            # Create a new folder and move the table there
+            folder_name, ok = QInputDialog.getText(
+                self,
+                "New Folder",
+                "Enter folder name:",
+                QLineEdit.EchoMode.Normal
+            )
+            if ok and folder_name:
+                folder = self.tables_list.create_folder(folder_name)
+                self.tables_list.move_item_to_folder(item, folder)
+                self.statusBar().showMessage(f'Moved table "{table_name}" to folder "{folder_name}"')
+        elif action == root_action:
+            # Move table to root (remove from any folder)
+            parent = item.parent()
+            if parent and self.tables_list.is_folder_item(parent):
+                # Create a clone at root level
+                source = item.text(0).split(' (')[1][:-1]  # Get the source part
+                needs_reload = table_name in self.tables_list.tables_needing_reload
+                # Remove from current parent
+                parent.removeChild(item)
+                # Add to root
+                self.tables_list.add_table_item(table_name, source, needs_reload)
+                self.statusBar().showMessage(f'Moved table "{table_name}" to root')
+        elif action and action.parent() == move_menu:
+            # Move to selected folder
+            target_folder = action.data()
+            if target_folder:
+                self.tables_list.move_item_to_folder(item, target_folder)
+                self.statusBar().showMessage(f'Moved table "{table_name}" to folder "{target_folder.text(0)}"')
 
-    def new_project(self):
+    def reload_selected_table(self, table_name=None):
+        """Reload the data for a table from its source file"""
+        try:
+            # If table_name is not provided, get it from the selected item
+            if not table_name:
+                current_item = self.tables_list.currentItem()
+                if not current_item:
+                    return
+                table_name = self.tables_list.get_table_name_from_item(current_item)
+            
+            # Show a loading indicator
+            self.statusBar().showMessage(f'Reloading table "{table_name}"...')
+            
+            # Use the database manager to reload the table
+            success, message = self.db_manager.reload_table(table_name)
+            
+            if success:
+                # Show success message
+                self.statusBar().showMessage(message)
+                
+                # Update completer with any new column names
+                self.update_completer()
+                
+                # Mark the table as reloaded (remove the reload icon)
+                self.tables_list.mark_table_reloaded(table_name)
+                
+                # Show a preview of the reloaded table
+                table_item = self.tables_list.find_table_item(table_name)
+                if table_item:
+                    self.show_table_preview(table_item)
+            else:
+                # Show error message
+                QMessageBox.warning(self, "Reload Failed", message)
+                self.statusBar().showMessage(f'Failed to reload table: {message}')
+                
+        except Exception as e:
+            QMessageBox.critical(self, "Error", 
+                f"Error reloading table:\n\n{str(e)}")
+            self.statusBar().showMessage('Error reloading table')
+
+    def new_project(self, skip_confirmation=False):
         """Create a new project by clearing current state"""
-        if self.db_manager.is_connected():
+        if self.db_manager.is_connected() and not skip_confirmation:
             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)
+                                      '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
                 self.db_manager.close_connection()
                 
+                # Clear all database tracking
+                self.db_manager.loaded_tables = {}
+                self.db_manager.table_columns = {}
+                
                 # Reset state
                 self.tables_list.clear()
                 
@@ -1594,6 +1424,34 @@ LIMIT 10
                 self.setWindowTitle('SQL Shell')
                 self.db_info_label.setText("No database connected")
                 self.statusBar().showMessage('New project created')
+        elif skip_confirmation:
+            # Skip confirmation and just clear everything
+            if self.db_manager.is_connected():
+                self.db_manager.close_connection()
+            
+            # Clear all database tracking
+            self.db_manager.loaded_tables = {}
+            self.db_manager.table_columns = {}
+            
+            # Reset state
+            self.tables_list.clear()
+            
+            # Clear all tabs except one
+            while self.tab_widget.count() > 1:
+                self.close_tab(1)  # Always close tab at index 1 to keep at least one tab
+            
+            # Clear the remaining tab
+            first_tab = self.get_tab_at_index(0)
+            if first_tab:
+                first_tab.set_query_text("")
+                first_tab.results_table.setRowCount(0)
+                first_tab.results_table.setColumnCount(0)
+                first_tab.row_count_label.setText("")
+                first_tab.results_title.setText("RESULTS")
+            
+            self.current_project_file = None
+            self.setWindowTitle('SQL Shell')
+            self.db_info_label.setText("No database connected")
 
     def save_project(self):
         """Save the current project"""
@@ -1634,6 +1492,7 @@ LIMIT 10
             
             project_data = {
                 'tables': {},
+                'folders': {},
                 'tabs': tabs_data,
                 'connection_type': self.db_manager.connection_type,
                 'database_path': None  # Initialize to None
@@ -1643,8 +1502,51 @@ LIMIT 10
             if self.db_manager.is_connected() and hasattr(self.db_manager, 'database_path'):
                 project_data['database_path'] = self.db_manager.database_path
             
-            # Save table information
-            for table_name, file_path in self.db_manager.loaded_tables.items():
+            # Helper function to recursively save folder structure
+            def save_folder_structure(parent_item, parent_path=""):
+                if parent_item is None:
+                    # Handle top-level items
+                    for i in range(self.tables_list.topLevelItemCount()):
+                        item = self.tables_list.topLevelItem(i)
+                        if self.tables_list.is_folder_item(item):
+                            # It's a folder - add to folders and process its children
+                            folder_name = item.text(0)
+                            folder_id = f"folder_{i}"
+                            project_data['folders'][folder_id] = {
+                                'name': folder_name,
+                                'parent': None,
+                                'expanded': item.isExpanded()
+                            }
+                            save_folder_structure(item, folder_id)
+                        else:
+                            # It's a table - add to tables at root level
+                            save_table_item(item)
+                else:
+                    # Process children of this folder
+                    for i in range(parent_item.childCount()):
+                        child = parent_item.child(i)
+                        if self.tables_list.is_folder_item(child):
+                            # It's a subfolder
+                            folder_name = child.text(0)
+                            folder_id = f"{parent_path}_sub_{i}"
+                            project_data['folders'][folder_id] = {
+                                'name': folder_name,
+                                'parent': parent_path,
+                                'expanded': child.isExpanded()
+                            }
+                            save_folder_structure(child, folder_id)
+                        else:
+                            # It's a table in this folder
+                            save_table_item(child, parent_path)
+            
+            # Helper function to save table item
+            def save_table_item(item, folder_id=None):
+                table_name = self.tables_list.get_table_name_from_item(item)
+                if not table_name or table_name not in self.db_manager.loaded_tables:
+                    return
+                    
+                file_path = self.db_manager.loaded_tables[table_name]
+                
                 # For database tables and query results, store the special identifier
                 if file_path in ['database', 'query_result']:
                     source_path = file_path
@@ -1654,9 +1556,13 @@ LIMIT 10
                 
                 project_data['tables'][table_name] = {
                     'file_path': source_path,
-                    'columns': self.db_manager.table_columns.get(table_name, [])
+                    'columns': self.db_manager.table_columns.get(table_name, []),
+                    'folder': folder_id
                 }
             
+            # Save the folder structure
+            save_folder_structure(None)
+            
             with open(file_name, 'w') as f:
                 json.dump(project_data, f, indent=4)
                 
@@ -1672,6 +1578,20 @@ LIMIT 10
     def open_project(self, file_name=None):
         """Open a project file"""
         if not file_name:
+            # Check for unsaved changes before showing file dialog
+            if self.has_unsaved_changes():
+                reply = QMessageBox.question(self, 'Save Changes',
+                    'Do you want to save your changes before opening another project?',
+                    QMessageBox.StandardButton.Save | 
+                    QMessageBox.StandardButton.Discard | 
+                    QMessageBox.StandardButton.Cancel)
+                
+                if reply == QMessageBox.StandardButton.Save:
+                    self.save_project()
+                elif reply == QMessageBox.StandardButton.Cancel:
+                    return
+            
+            # Show file dialog after handling save prompt
             file_name, _ = QFileDialog.getOpenFileName(
                 self,
                 "Open Project",
@@ -1697,46 +1617,53 @@ LIMIT 10
                 QApplication.processEvents()
                 
                 # Start fresh
-                self.new_project()
+                self.new_project(skip_confirmation=True)
                 progress.setValue(15)
                 QApplication.processEvents()
                 
+                # Make sure all database tables are cleared from tracking
+                self.db_manager.loaded_tables = {}
+                self.db_manager.table_columns = {}
+                
                 # Check if there's a database path in the project
                 has_database_path = 'database_path' in project_data and project_data['database_path']
                 has_database_tables = any(table_info.get('file_path') == 'database' 
                                        for table_info in project_data.get('tables', {}).values())
                 
-                # Set a flag to track if database tables are loaded
+                # Connect to database if needed
+                progress.setLabelText("Connecting to database...")
                 database_tables_loaded = False
+                database_connection_message = None
                 
-                # If the project contains database tables and a database path, try to connect to it
-                progress.setLabelText("Connecting to database...")
                 if has_database_path and has_database_tables:
                     database_path = project_data['database_path']
                     try:
                         if os.path.exists(database_path):
                             # Connect to the database
-                            self.db_manager.open_database(database_path)
+                            self.db_manager.open_database(database_path, load_all_tables=False)
                             self.db_info_label.setText(self.db_manager.get_connection_info())
                             self.statusBar().showMessage(f"Connected to database: {database_path}")
                             
-                            # Add all database tables to the tables list
-                            for table_name, source in self.db_manager.loaded_tables.items():
-                                if source == 'database':
-                                    self.tables_list.addItem(f"{table_name} (database)")
-                            
                             # Mark database tables as loaded
                             database_tables_loaded = True
                         else:
                             database_tables_loaded = False
-                            QMessageBox.warning(self, "Database Not Found",
+                            # Store the message instead of showing immediately
+                            database_connection_message = (
+                                "Database Not Found", 
                                 f"The project's database file was not found at:\n{database_path}\n\n"
-                                "Database tables will be shown but not accessible until you reconnect to the database.")
+                                "Database tables will be shown but not accessible until you reconnect to the database.\n\n"
+                                "Use the 'Open Database' button to connect to your database file."
+                            )
                     except Exception as e:
                         database_tables_loaded = False
-                        QMessageBox.warning(self, "Database Connection Error",
+                        # Store the message instead of showing immediately
+                        database_connection_message = (
+                            "Database Connection Error",
                             f"Failed to connect to the project's database:\n{str(e)}\n\n"
-                            "Database tables will be shown but not accessible until you reconnect to the database.")
+                            "Database tables will be shown but not accessible until you reconnect to the database.\n\n"
+                            "Use the 'Open Database' button to connect to your database file."
+                        )
                 else:
                     # Create connection if needed (we don't have a specific database to connect to)
                     database_tables_loaded = False
@@ -1745,11 +1672,52 @@ LIMIT 10
                         self.db_info_label.setText(connection_info)
                     elif 'connection_type' in project_data and project_data['connection_type'] != self.db_manager.connection_type:
                         # If connected but with a different database type than what was saved in the project
-                        QMessageBox.warning(self, "Database Type Mismatch",
+                        # Store the message instead of showing immediately
+                        database_connection_message = (
+                            "Database Type Mismatch",
                             f"The project was saved with a {project_data['connection_type']} database, but you're currently using {self.db_manager.connection_type}.\n\n"
-                            "Some database-specific features may not work correctly. Consider reconnecting to the correct database type.")
+                            "Some database-specific features may not work correctly. Consider reconnecting to the correct database type."
+                        )
                 
-                progress.setValue(30)
+                progress.setValue(20)
+                QApplication.processEvents()
+                
+                # First, recreate the folder structure
+                folder_items = {}  # Store folder items by ID
+                
+                # Create folders first
+                if 'folders' in project_data:
+                    progress.setLabelText("Creating folders...")
+                    # First pass: create top-level folders
+                    for folder_id, folder_info in project_data['folders'].items():
+                        if folder_info.get('parent') is None:
+                            # Create top-level folder
+                            folder = self.tables_list.create_folder(folder_info['name'])
+                            folder_items[folder_id] = folder
+                            # Set expanded state
+                            folder.setExpanded(folder_info.get('expanded', True))
+                    
+                    # Second pass: create subfolders
+                    for folder_id, folder_info in project_data['folders'].items():
+                        parent_id = folder_info.get('parent')
+                        if parent_id is not None and parent_id in folder_items:
+                            # Create subfolder under parent
+                            parent_folder = folder_items[parent_id]
+                            subfolder = QTreeWidgetItem(parent_folder)
+                            subfolder.setText(0, folder_info['name'])
+                            subfolder.setIcon(0, QIcon.fromTheme("folder"))
+                            subfolder.setData(0, Qt.ItemDataRole.UserRole, "folder")
+                            # Make folder text bold
+                            font = subfolder.font(0)
+                            font.setBold(True)
+                            subfolder.setFont(0, font)
+                            # Set folder flags
+                            subfolder.setFlags(subfolder.flags() | Qt.ItemFlag.ItemIsDropEnabled)
+                            # Set expanded state
+                            subfolder.setExpanded(folder_info.get('expanded', True))
+                            folder_items[folder_id] = subfolder
+                            
+                progress.setValue(25)
                 QApplication.processEvents()
                 
                 # Calculate progress steps for loading tables
@@ -1764,59 +1732,113 @@ LIMIT 10
                     if progress.wasCanceled():
                         break
                         
-                    progress.setLabelText(f"Loading table: {table_name}")
+                    progress.setLabelText(f"Processing table: {table_name}")
                     file_path = table_info['file_path']
+                    self.statusBar().showMessage(f"Processing table: {table_name} from {file_path}")
+                    
                     try:
+                        # Determine folder placement
+                        folder_id = table_info.get('folder')
+                        parent_folder = folder_items.get(folder_id) if folder_id else None
+                        
                         if file_path == 'database':
-                            # Skip if we already loaded database tables by connecting to the database
+                            # Different handling based on whether database connection is active
                             if database_tables_loaded:
-                                continue
+                                # Store table info without loading data
+                                self.db_manager.loaded_tables[table_name] = 'database'
+                                if 'columns' in table_info:
+                                    self.db_manager.table_columns[table_name] = table_info['columns']
+                                    
+                                # Create item without reload icon
+                                if parent_folder:
+                                    # Add to folder
+                                    item = QTreeWidgetItem(parent_folder)
+                                    item.setText(0, f"{table_name} (database)")
+                                    item.setIcon(0, QIcon.fromTheme("x-office-spreadsheet"))
+                                    item.setData(0, Qt.ItemDataRole.UserRole, "table")
+                                else:
+                                    # Add to root
+                                    self.tables_list.add_table_item(table_name, "database", needs_reload=False)
+                            else:
+                                # No active database connection, just register the table name
+                                self.db_manager.loaded_tables[table_name] = 'database'
+                                if 'columns' in table_info:
+                                    self.db_manager.table_columns[table_name] = table_info['columns']
                                 
-                            # For database tables, we need to check if the original database is connected
-                            # Don't try to SELECT from non-existent tables
-                            # Instead just register the table name for UI display
-                            self.db_manager.loaded_tables[table_name] = 'database'
-                            
-                            # If we have column information, use it
-                            if 'columns' in table_info:
-                                self.db_manager.table_columns[table_name] = table_info['columns']
-                            
-                            # Add to the UI list
-                            self.tables_list.addItem(f"{table_name} (database)")
+                                # Create item with reload icon
+                                if parent_folder:
+                                    # Add to folder
+                                    item = QTreeWidgetItem(parent_folder)
+                                    item.setText(0, f"{table_name} (database)")
+                                    item.setIcon(0, QIcon.fromTheme("view-refresh"))
+                                    item.setData(0, Qt.ItemDataRole.UserRole, "table")
+                                    item.setToolTip(0, f"Table '{table_name}' needs to be loaded (double-click or use context menu)")
+                                    self.tables_list.tables_needing_reload.add(table_name)
+                                else:
+                                    # Add to root
+                                    self.tables_list.add_table_item(table_name, "database", needs_reload=True)
                         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
+                            # For tables from query results, just note it as a query result table
                             self.db_manager.loaded_tables[table_name] = 'query_result'
-                            self.tables_list.addItem(f"{table_name} (query result)")
+                            
+                            # Create item with reload icon
+                            if parent_folder:
+                                # Add to folder
+                                item = QTreeWidgetItem(parent_folder)
+                                item.setText(0, f"{table_name} (query result)")
+                                item.setIcon(0, QIcon.fromTheme("view-refresh"))
+                                item.setData(0, Qt.ItemDataRole.UserRole, "table")
+                                item.setToolTip(0, f"Table '{table_name}' needs to be loaded (double-click or use context menu)")
+                                self.tables_list.tables_needing_reload.add(table_name)
+                            else:
+                                # Add to root
+                                self.tables_list.add_table_item(table_name, "query result", needs_reload=True)
                         elif os.path.exists(file_path):
-                            # Use the database manager to load the file
-                            try:
-                                loaded_table_name, df = self.db_manager.load_file(file_path)
-                                self.tables_list.addItem(f"{loaded_table_name} ({os.path.basename(file_path)})")
-                            except Exception as e:
-                                QMessageBox.warning(self, "Warning",
-                                    f"Failed to load file for table {table_name}:\n{str(e)}")
-                                continue
+                            # Register the file as a table source but don't load data yet
+                            self.db_manager.loaded_tables[table_name] = file_path
+                            if 'columns' in table_info:
+                                self.db_manager.table_columns[table_name] = table_info['columns']
+                                
+                            # Create item with reload icon
+                            if parent_folder:
+                                # Add to folder
+                                item = QTreeWidgetItem(parent_folder)
+                                item.setText(0, f"{table_name} ({os.path.basename(file_path)})")
+                                item.setIcon(0, QIcon.fromTheme("view-refresh"))
+                                item.setData(0, Qt.ItemDataRole.UserRole, "table")
+                                item.setToolTip(0, f"Table '{table_name}' needs to be loaded (double-click or use context menu)")
+                                self.tables_list.tables_needing_reload.add(table_name)
+                            else:
+                                # Add to root
+                                self.tables_list.add_table_item(table_name, os.path.basename(file_path), needs_reload=True)
                         else:
-                            QMessageBox.warning(self, "Warning",
-                                f"Could not find file for table {table_name}: {file_path}")
-                            continue
+                            # File doesn't exist, but add to list with warning
+                            self.db_manager.loaded_tables[table_name] = file_path
+                            if 'columns' in table_info:
+                                self.db_manager.table_columns[table_name] = table_info['columns']
+                                
+                            # Create item with reload icon and missing warning
+                            if parent_folder:
+                                # Add to folder
+                                item = QTreeWidgetItem(parent_folder)
+                                item.setText(0, f"{table_name} ({os.path.basename(file_path)} (missing))")
+                                item.setIcon(0, QIcon.fromTheme("view-refresh"))
+                                item.setData(0, Qt.ItemDataRole.UserRole, "table")
+                                item.setToolTip(0, f"Table '{table_name}' needs to be loaded (double-click or use context menu)")
+                                self.tables_list.tables_needing_reload.add(table_name)
+                            else:
+                                # Add to root
+                                self.tables_list.add_table_item(table_name, f"{os.path.basename(file_path)} (missing)", needs_reload=True)
                             
                     except Exception as e:
                         QMessageBox.warning(self, "Warning",
-                            f"Failed to load table {table_name}:\n{str(e)}")
+                            f"Failed to process table {table_name}:\n{str(e)}")
                 
                     # Update progress for this table
                     current_progress += table_progress_step
                     progress.setValue(int(current_progress))
                     QApplication.processEvents()  # Keep UI responsive
                 
-                # If the project had database tables but we couldn't connect automatically, notify the user
-                if has_database_tables and not database_tables_loaded:
-                    QMessageBox.information(self, "Database Connection Required",
-                        "This project contains database tables. You need to reconnect to the database to use them.\n\n"
-                        "Use the 'Open Database' button to connect to your database file.")
-                
                 # Check if the operation was canceled
                 if progress.wasCanceled():
                     self.statusBar().showMessage("Project loading was canceled")
@@ -1919,9 +1941,25 @@ LIMIT 10
                 progress.setValue(100)
                 QApplication.processEvents()
                 
-                self.statusBar().showMessage(f'Project loaded from {file_name}')
+                # Show message about tables needing reload
+                reload_count = len(self.tables_list.tables_needing_reload)
+                if reload_count > 0:
+                    self.statusBar().showMessage(
+                        f'Project loaded from {file_name} with {table_count} tables. {reload_count} tables need to be reloaded (click reload icon).'
+                    )
+                else:
+                    self.statusBar().showMessage(
+                        f'Project loaded from {file_name} with {table_count} tables.'
+                    )
+                
+                # Close progress dialog before showing message boxes
                 progress.close()
                 
+                # Now show any database connection message we stored earlier
+                if database_connection_message and not database_tables_loaded and has_database_tables:
+                    title, message = database_connection_message
+                    QMessageBox.warning(self, title, message)
+                
             except Exception as e:
                 QMessageBox.critical(self, "Error",
                     f"Failed to open project:\n\n{str(e)}")
@@ -1952,6 +1990,10 @@ LIMIT 10
                     settings = json.load(f)
                     self.recent_projects = settings.get('recent_projects', [])
                     
+                    # Load user preferences
+                    preferences = settings.get('preferences', {})
+                    self.auto_load_recent_project = preferences.get('auto_load_recent_project', True)
+                    
                     # Load window settings if available
                     window_settings = settings.get('window', {})
                     if window_settings:
@@ -1969,10 +2011,19 @@ LIMIT 10
                     settings = json.load(f)
             settings['recent_projects'] = self.recent_projects
             
+            # Save user preferences
+            if 'preferences' not in settings:
+                settings['preferences'] = {}
+            settings['preferences']['auto_load_recent_project'] = self.auto_load_recent_project
+            
             # Save window settings
             window_settings = self.save_window_state()
             settings['window'] = window_settings
             
+            # Also save recent and frequent files data
+            settings['recent_files'] = self.recent_files
+            settings['frequent_files'] = self.frequent_files
+            
             with open(settings_file, 'w') as f:
                 json.dump(settings, f, indent=4)
         except Exception as e:
@@ -2064,6 +2115,20 @@ LIMIT 10
     def open_recent_project(self, project_path):
         """Open a project from the recent projects list"""
         if os.path.exists(project_path):
+            # Check if current project has unsaved changes before loading the new one
+            if self.has_unsaved_changes():
+                reply = QMessageBox.question(self, 'Save Changes',
+                    'Do you want to save your changes before loading another project?',
+                    QMessageBox.StandardButton.Save | 
+                    QMessageBox.StandardButton.Discard | 
+                    QMessageBox.StandardButton.Cancel)
+                
+                if reply == QMessageBox.StandardButton.Save:
+                    self.save_project()
+                elif reply == QMessageBox.StandardButton.Cancel:
+                    return
+            
+            # Now proceed with loading the project
             self.current_project_file = project_path
             self.open_project(project_path)
         else:
@@ -2079,6 +2144,246 @@ LIMIT 10
         self.save_recent_projects()
         self.update_recent_projects_menu()
 
+    def load_recent_files(self):
+        """Load recent and frequent files from settings file"""
+        try:
+            settings_file = os.path.join(os.path.expanduser('~'), '.sqlshell_settings.json')
+            if os.path.exists(settings_file):
+                with open(settings_file, 'r') as f:
+                    settings = json.load(f)
+                    self.recent_files = settings.get('recent_files', [])
+                    self.frequent_files = settings.get('frequent_files', {})
+        except Exception:
+            self.recent_files = []
+            self.frequent_files = {}
+
+    def save_recent_files(self):
+        """Save recent and frequent files to settings file"""
+        try:
+            settings_file = os.path.join(os.path.expanduser('~'), '.sqlshell_settings.json')
+            settings = {}
+            if os.path.exists(settings_file):
+                with open(settings_file, 'r') as f:
+                    settings = json.load(f)
+            settings['recent_files'] = self.recent_files
+            settings['frequent_files'] = self.frequent_files
+            
+            with open(settings_file, 'w') as f:
+                json.dump(settings, f, indent=4)
+        except Exception as e:
+            print(f"Error saving recent files: {e}")
+
+    def add_recent_file(self, file_path):
+        """Add a file to recent files list and update frequent files count"""
+        file_path = os.path.abspath(file_path)
+        
+        # Update recent files
+        if file_path in self.recent_files:
+            self.recent_files.remove(file_path)
+        self.recent_files.insert(0, file_path)
+        self.recent_files = self.recent_files[:self.max_recent_files]
+        
+        # Update frequency count
+        if file_path in self.frequent_files:
+            self.frequent_files[file_path] += 1
+        else:
+            self.frequent_files[file_path] = 1
+        
+        # Save to settings
+        self.save_recent_files()
+        
+        # Update the quick access menu if it exists
+        if hasattr(self, 'quick_access_menu'):
+            self.update_quick_access_menu()
+
+    def get_frequent_files(self, limit=10):
+        """Get the most frequently used files"""
+        sorted_files = sorted(
+            self.frequent_files.items(), 
+            key=lambda item: item[1], 
+            reverse=True
+        )
+        return [path for path, count in sorted_files[:limit] if os.path.exists(path)]
+
+    def clear_recent_files(self):
+        """Clear the list of recent files"""
+        self.recent_files.clear()
+        self.save_recent_files()
+        if hasattr(self, 'quick_access_menu'):
+            self.update_quick_access_menu()
+
+    def clear_frequent_files(self):
+        """Clear the list of frequent files"""
+        self.frequent_files.clear()
+        self.save_recent_files()
+        if hasattr(self, 'quick_access_menu'):
+            self.update_quick_access_menu()
+
+    def update_quick_access_menu(self):
+        """Update the quick access menu with recent and frequent files"""
+        if not hasattr(self, 'quick_access_menu'):
+            return
+            
+        self.quick_access_menu.clear()
+        
+        # Add "Recent Files" section
+        if self.recent_files:
+            recent_section = self.quick_access_menu.addSection("Recent Files")
+            
+            for file_path in self.recent_files[:10]:  # Show top 10 recent files
+                if os.path.exists(file_path):
+                    file_name = os.path.basename(file_path)
+                    action = self.quick_access_menu.addAction(file_name)
+                    action.setData(file_path)
+                    action.setToolTip(file_path)
+                    action.triggered.connect(lambda checked, path=file_path: self.quick_open_file(path))
+        
+        # Add "Frequently Used Files" section
+        frequent_files = self.get_frequent_files(10)  # Get top 10 frequent files
+        if frequent_files:
+            self.quick_access_menu.addSeparator()
+            freq_section = self.quick_access_menu.addSection("Frequently Used Files")
+            
+            for file_path in frequent_files:
+                file_name = os.path.basename(file_path)
+                count = self.frequent_files.get(file_path, 0)
+                action = self.quick_access_menu.addAction(f"{file_name} ({count} uses)")
+                action.setData(file_path)
+                action.setToolTip(file_path)
+                action.triggered.connect(lambda checked, path=file_path: self.quick_open_file(path))
+        
+        # Add management options if we have any files
+        if self.recent_files or self.frequent_files:
+            self.quick_access_menu.addSeparator()
+            clear_recent = self.quick_access_menu.addAction("Clear Recent Files")
+            clear_recent.triggered.connect(self.clear_recent_files)
+            
+            clear_frequent = self.quick_access_menu.addAction("Clear Frequent Files")
+            clear_frequent.triggered.connect(self.clear_frequent_files)
+        else:
+            # No files placeholder
+            no_files = self.quick_access_menu.addAction("No Recent Files")
+            no_files.setEnabled(False)
+
+    def quick_open_file(self, file_path):
+        """Open a file from the quick access menu"""
+        if not os.path.exists(file_path):
+            QMessageBox.warning(self, "File Not Found", 
+                f"The file no longer exists:\n{file_path}")
+            
+            # Remove from tracking
+            if file_path in self.recent_files:
+                self.recent_files.remove(file_path)
+            if file_path in self.frequent_files:
+                del self.frequent_files[file_path]
+            self.save_recent_files()
+            self.update_quick_access_menu()
+            return
+        
+        try:
+            # Determine file type
+            file_ext = os.path.splitext(file_path)[1].lower()
+            
+            # Check if this is a Delta table directory
+            is_delta_table = False
+            if os.path.isdir(file_path):
+                delta_path = Path(file_path)
+                delta_log_path = delta_path / '_delta_log'
+                if delta_log_path.exists():
+                    is_delta_table = True
+            
+            if is_delta_table:
+                # Delta table directory
+                if not self.db_manager.is_connected():
+                    # Create a default in-memory DuckDB connection if none exists
+                    connection_info = self.db_manager.create_memory_connection()
+                    self.db_info_label.setText(connection_info)
+                
+                # Use the database manager to load the Delta table
+                table_name, df = self.db_manager.load_file(file_path)
+                
+                # Update UI using new method
+                self.tables_list.add_table_item(table_name, os.path.basename(file_path))
+                self.statusBar().showMessage(f'Loaded Delta table from {file_path} as "{table_name}"')
+                
+                # Show preview of loaded data
+                preview_df = df.head()
+                current_tab = self.get_current_tab()
+                if current_tab:
+                    self.populate_table(preview_df)
+                    current_tab.results_title.setText(f"PREVIEW: {table_name}")
+                
+                # Update completer with new table and column names
+                self.update_completer()
+            elif file_ext in ['.db', '.sqlite', '.sqlite3']:
+                # Database file
+                # Clear existing database tables from the list widget
+                for i in range(self.tables_list.topLevelItemCount() - 1, -1, -1):
+                    item = self.tables_list.topLevelItem(i)
+                    if item and item.text(0).endswith('(database)'):
+                        self.tables_list.takeTopLevelItem(i)
+                
+                # Use the database manager to open the database
+                self.db_manager.open_database(file_path)
+                
+                # Update UI with tables from the database using new method
+                for table_name, source in self.db_manager.loaded_tables.items():
+                    if source == 'database':
+                        self.tables_list.add_table_item(table_name, "database")
+                
+                # Update the completer with table and column names
+                self.update_completer()
+                
+                # Update status bar
+                self.statusBar().showMessage(f"Connected to database: {file_path}")
+                self.db_info_label.setText(self.db_manager.get_connection_info())
+                
+            elif file_ext in ['.xlsx', '.xls', '.csv', '.parquet']:
+                # Data file
+                if not self.db_manager.is_connected():
+                    # Create a default in-memory DuckDB connection if none exists
+                    connection_info = self.db_manager.create_memory_connection()
+                    self.db_info_label.setText(connection_info)
+                
+                # Use the database manager to load the file
+                table_name, df = self.db_manager.load_file(file_path)
+                
+                # Update UI using new method
+                self.tables_list.add_table_item(table_name, os.path.basename(file_path))
+                self.statusBar().showMessage(f'Loaded {file_path} as table "{table_name}"')
+                
+                # Show preview of loaded data
+                preview_df = df.head()
+                current_tab = self.get_current_tab()
+                if current_tab:
+                    self.populate_table(preview_df)
+                    current_tab.results_title.setText(f"PREVIEW: {table_name}")
+                
+                # Update completer with new table and column names
+                self.update_completer()
+            else:
+                QMessageBox.warning(self, "Unsupported File Type", 
+                    f"The file type {file_ext} is not supported.")
+                return
+            
+            # Update tracking - increment usage count
+            self.add_recent_file(file_path)
+            
+        except Exception as e:
+            QMessageBox.critical(self, "Error", 
+                f"Failed to open file:\n\n{str(e)}")
+            self.statusBar().showMessage(f"Error opening file: {os.path.basename(file_path)}")
+
+    def show_quick_access_menu(self):
+        """Display the quick access menu when the button is clicked"""
+        # First, make sure the menu is up to date
+        self.update_quick_access_menu()
+        
+        # Show the menu below the quick access button
+        if hasattr(self, 'quick_access_menu') and hasattr(self, 'quick_access_btn'):
+            self.quick_access_menu.popup(self.quick_access_btn.mapToGlobal(
+                QPoint(0, self.quick_access_btn.height())))
+
     def add_tab(self, title="Query 1"):
         """Add a new query tab"""
         # Ensure title is a string
@@ -2123,6 +2428,24 @@ LIMIT 10
         # Process events to keep UI responsive
         QApplication.processEvents()
         
+        # Update completer for the new tab
+        try:
+            from sqlshell.suggester_integration import get_suggestion_manager
+            
+            # Get the suggestion manager singleton
+            suggestion_mgr = get_suggestion_manager()
+            
+            # Register the new editor with a unique ID
+            editor_id = f"tab_{index}_{id(tab.query_edit)}"
+            suggestion_mgr.register_editor(tab.query_edit, editor_id)
+            
+            # Apply the current completer model if available
+            if hasattr(self, '_current_completer_model'):
+                tab.query_edit.update_completer_model(self._current_completer_model)
+        except Exception as e:
+            # Don't let autocomplete errors affect tab creation
+            print(f"Error setting up autocomplete for new tab: {e}")
+        
         return tab
     
     def duplicate_current_tab(self):
@@ -2199,11 +2522,27 @@ LIMIT 10
                 tab.results_table.setColumnCount(0)
             return
             
+        # Get the widget before removing the tab
+        widget = self.tab_widget.widget(index)
+        
+        # Unregister the editor from the suggestion manager before closing
+        try:
+            from sqlshell.suggester_integration import get_suggestion_manager
+            suggestion_mgr = get_suggestion_manager()
+            
+            # Find and unregister this editor
+            for editor_id in list(suggestion_mgr._editors.keys()):
+                if editor_id.startswith(f"tab_{index}_") or (hasattr(widget, 'query_edit') and 
+                    str(id(widget.query_edit)) in editor_id):
+                    suggestion_mgr.unregister_editor(editor_id)
+        except Exception as e:
+            # Don't let errors affect tab closing
+            print(f"Error unregistering editor from suggestion manager: {e}")
+        
         # Block signals temporarily to improve performance when removing multiple tabs
         was_blocked = self.tab_widget.blockSignals(True)
         
         # Remove the tab
-        widget = self.tab_widget.widget(index)
         self.tab_widget.removeTab(index)
         
         # Restore signals
@@ -2218,6 +2557,36 @@ LIMIT 10
         
         # Process events to keep UI responsive
         QApplication.processEvents()
+        
+        # Update tab indices in the suggestion manager
+        QTimer.singleShot(100, self.update_tab_indices_in_suggestion_manager)
+    
+    def update_tab_indices_in_suggestion_manager(self):
+        """Update tab indices in the suggestion manager after tab removal"""
+        try:
+            from sqlshell.suggester_integration import get_suggestion_manager
+            suggestion_mgr = get_suggestion_manager()
+            
+            # Get current editors
+            old_editors = suggestion_mgr._editors.copy()
+            old_completers = suggestion_mgr._completers.copy()
+            
+            # Clear current registrations
+            suggestion_mgr._editors.clear()
+            suggestion_mgr._completers.clear()
+            
+            # Re-register with updated indices
+            for i in range(self.tab_widget.count()):
+                tab = self.tab_widget.widget(i)
+                if tab and hasattr(tab, 'query_edit'):
+                    # Register with new index
+                    editor_id = f"tab_{i}_{id(tab.query_edit)}"
+                    suggestion_mgr._editors[editor_id] = tab.query_edit
+                    if hasattr(tab.query_edit, 'completer') and tab.query_edit.completer:
+                        suggestion_mgr._completers[editor_id] = tab.query_edit.completer
+        except Exception as e:
+            # Don't let errors affect application
+            print(f"Error updating tab indices in suggestion manager: {e}")
     
     def close_current_tab(self):
         """Close the current tab"""
@@ -2317,7 +2686,544 @@ LIMIT 10
         except Exception as e:
             self.statusBar().showMessage(f"Error resetting zoom: {str(e)}", 2000)
 
+    def load_most_recent_project(self):
+        """Load the most recent project if available"""
+        if self.recent_projects:
+            most_recent_project = self.recent_projects[0]
+            if os.path.exists(most_recent_project):
+                self.open_project(most_recent_project)
+                self.statusBar().showMessage(f"Auto-loaded most recent project: {os.path.basename(most_recent_project)}")
+            else:
+                # Remove the non-existent project from the list
+                self.recent_projects.remove(most_recent_project)
+                self.save_recent_projects()
+                # Try the next project if available
+                if self.recent_projects:
+                    self.load_most_recent_project()
+
+    def load_delta_table(self):
+        """Load a Delta table from a directory"""
+        if not self.db_manager.is_connected():
+            # Create a default in-memory DuckDB connection if none exists
+            connection_info = self.db_manager.create_memory_connection()
+            self.db_info_label.setText(connection_info)
+            
+        # Get directory containing the Delta table
+        delta_dir = QFileDialog.getExistingDirectory(
+            self,
+            "Select Delta Table Directory",
+            "",
+            QFileDialog.Option.ShowDirsOnly | QFileDialog.Option.DontResolveSymlinks
+        )
+        
+        if not delta_dir:
+            return
+            
+        # Check if this is a valid Delta table directory
+        delta_path = Path(delta_dir)
+        delta_log_path = delta_path / '_delta_log'
+        
+        if not delta_log_path.exists():
+            # Ask if they want to select a subdirectory
+            subdirs = [d for d in delta_path.iterdir() if d.is_dir() and (d / '_delta_log').exists()]
+            
+            if subdirs:
+                # There are subdirectories with Delta tables
+                msg = QMessageBox()
+                msg.setIcon(QMessageBox.Icon.Information)
+                msg.setWindowTitle("Select Subdirectory")
+                msg.setText(f"The selected directory does not contain a Delta table, but it contains {len(subdirs)} subdirectories with Delta tables.")
+                msg.setInformativeText("Would you like to select one of these subdirectories?")
+                msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+                msg.setDefaultButton(QMessageBox.StandardButton.Yes)
+                
+                if msg.exec() == QMessageBox.StandardButton.Yes:
+                    # Create a dialog to select a subdirectory
+                    subdir_names = [d.name for d in subdirs]
+                    subdir, ok = QInputDialog.getItem(
+                        self,
+                        "Select Delta Subdirectory",
+                        "Choose a subdirectory containing a Delta table:",
+                        subdir_names,
+                        0,
+                        False
+                    )
+                    
+                    if not ok or not subdir:
+                        return
+                        
+                    delta_dir = str(delta_path / subdir)
+                    delta_path = Path(delta_dir)
+                else:
+                    # Show error and return
+                    QMessageBox.critical(self, "Invalid Delta Table", 
+                        "The selected directory does not contain a Delta table (_delta_log directory not found).")
+                    return
+            else:
+                # No Delta tables found
+                QMessageBox.critical(self, "Invalid Delta Table", 
+                    "The selected directory does not contain a Delta table (_delta_log directory not found).")
+                return
+        
+        try:
+            # Add to recent files
+            self.add_recent_file(delta_dir)
+            
+            # Use the database manager to load the Delta table
+            import os
+            table_name, df = self.db_manager.load_file(delta_dir)
+            
+            # Update UI using new method
+            self.tables_list.add_table_item(table_name, os.path.basename(delta_dir))
+            self.statusBar().showMessage(f'Loaded Delta table from {delta_dir} as "{table_name}"')
+            
+            # Show preview of loaded data
+            preview_df = df.head()
+            self.populate_table(preview_df)
+            
+            # Update results title to show preview
+            current_tab = self.get_current_tab()
+            if current_tab:
+                current_tab.results_title.setText(f"PREVIEW: {table_name}")
+            
+            # Update completer with new table and column names
+            self.update_completer()
+            
+        except Exception as e:
+            error_msg = f'Error loading Delta table from {os.path.basename(delta_dir)}: {str(e)}'
+            self.statusBar().showMessage(error_msg)
+            QMessageBox.critical(self, "Error", error_msg)
+            
+            current_tab = self.get_current_tab()
+            if current_tab:
+                current_tab.results_table.setRowCount(0)
+                current_tab.results_table.setColumnCount(0)
+                current_tab.row_count_label.setText("")
+
+    def show_load_dialog(self):
+        """Show a modern dialog with options to load different types of data"""
+        # Create the dialog
+        dialog = QDialog(self)
+        dialog.setWindowTitle("Load Data")
+        dialog.setMinimumWidth(450)
+        dialog.setMinimumHeight(520)
+        
+        # Create a layout for the dialog
+        layout = QVBoxLayout(dialog)
+        layout.setSpacing(24)
+        layout.setContentsMargins(30, 30, 30, 30)
+        
+        # Header section with title and logo
+        header_layout = QHBoxLayout()
+        
+        # Title label with gradient effect
+        title_label = QLabel("Load Data")
+        title_font = QFont()
+        title_font.setPointSize(20)
+        title_font.setBold(True)
+        title_label.setFont(title_font)
+        title_label.setStyleSheet("""
+            font-weight: bold;
+            background: -webkit-linear-gradient(#2C3E50, #3498DB);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+        """)
+        header_layout.addWidget(title_label, 1)
+        
+        # Try to add a small logo image
+        try:
+            icon_path = os.path.join(os.path.dirname(__file__), "resources", "icon.png")
+            if os.path.exists(icon_path):
+                logo_label = QLabel()
+                logo_pixmap = QPixmap(icon_path).scaled(48, 48, Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.SmoothTransformation)
+                logo_label.setPixmap(logo_pixmap)
+                header_layout.addWidget(logo_label)
+        except Exception:
+            pass  # Skip logo if any issues
+            
+        layout.addLayout(header_layout)
+        
+        # Description with clearer styling
+        desc_label = QLabel("Choose a data source to load into SQLShell")
+        desc_label.setStyleSheet("color: #7F8C8D; font-size: 14px; margin: 4px 0 12px 0;")
+        layout.addWidget(desc_label)
+        
+        # Add separator line
+        separator = QFrame()
+        separator.setFrameShape(QFrame.Shape.HLine)
+        separator.setFrameShadow(QFrame.Shadow.Sunken)
+        separator.setStyleSheet("background-color: #E0E0E0; min-height: 1px; max-height: 1px;")
+        layout.addWidget(separator)
+        
+        # Create option cards with icons, titles and descriptions
+        options_layout = QVBoxLayout()
+        options_layout.setSpacing(16)
+        options_layout.setContentsMargins(0, 10, 0, 10)
+        
+        # Store animation references to prevent garbage collection
+        animations = []
+        
+        # Function to create hover animations for cards
+        def create_hover_animations(card):
+            # Store original stylesheet
+            original_style = card.styleSheet()
+            hover_style = """
+                background-color: #F8F9FA;
+                border: 1px solid #3498DB;
+                border-radius: 8px;
+            """
+            
+            # Function to handle enter event with animation
+            def enterEvent(event):
+                # Create and configure animation
+                anim = QPropertyAnimation(card, b"geometry")
+                anim.setDuration(150)
+                current_geo = card.geometry()
+                target_geo = QRect(
+                    current_geo.x() - 3,  # Slight shift to left for effect
+                    current_geo.y(),
+                    current_geo.width() + 6,  # Slight growth in width
+                    current_geo.height()
+                )
+                anim.setStartValue(current_geo)
+                anim.setEndValue(target_geo)
+                anim.setEasingCurve(QEasingCurve.Type.OutCubic)
+                
+                # Set hover style
+                card.setStyleSheet(hover_style)
+                # Start animation
+                anim.start()
+                # Keep reference to prevent garbage collection
+                animations.append(anim)
+                
+                # Call original enter event if it exists
+                original_enter = getattr(card, "_original_enterEvent", None)
+                if original_enter:
+                    original_enter(event)
+            
+            # Function to handle leave event with animation
+            def leaveEvent(event):
+                # Create and configure animation to return to original state
+                anim = QPropertyAnimation(card, b"geometry")
+                anim.setDuration(200)
+                current_geo = card.geometry()
+                original_geo = QRect(
+                    current_geo.x() + 3,  # Shift back to original position
+                    current_geo.y(),
+                    current_geo.width() - 6,  # Shrink back to original width
+                    current_geo.height()
+                )
+                anim.setStartValue(current_geo)
+                anim.setEndValue(original_geo)
+                anim.setEasingCurve(QEasingCurve.Type.OutCubic)
+                
+                # Restore original style
+                card.setStyleSheet(original_style)
+                # Start animation
+                anim.start()
+                # Keep reference to prevent garbage collection
+                animations.append(anim)
+                
+                # Call original leave event if it exists
+                original_leave = getattr(card, "_original_leaveEvent", None)
+                if original_leave:
+                    original_leave(event)
+            
+            # Store original event handlers and set new ones
+            card._original_enterEvent = card.enterEvent
+            card._original_leaveEvent = card.leaveEvent
+            card.enterEvent = enterEvent
+            card.leaveEvent = leaveEvent
+            
+            return card
+        
+        # Function to create styled option buttons with descriptions
+        def create_option_button(title, description, icon_name, option_type, accent_color="#3498DB"):
+            # Create container frame
+            container = QFrame()
+            container.setObjectName("optionCard")
+            container.setCursor(Qt.CursorShape.PointingHandCursor)
+            container.setProperty("optionType", option_type)
+            
+            # Set frame style
+            container.setFrameShape(QFrame.Shape.StyledPanel)
+            container.setLineWidth(1)
+            container.setMinimumHeight(90)
+            container.setStyleSheet(f"""
+                background-color: #FFFFFF;
+                border-radius: 10px;
+                border: 1px solid #E0E0E0;
+            """)
+            
+            # Create layout for the container
+            card_layout = QHBoxLayout(container)
+            card_layout.setContentsMargins(20, 16, 20, 16)
+            
+            # Add icon with colored circle background
+            icon_container = QFrame()
+            icon_container.setFixedSize(QSize(50, 50))
+            icon_container.setStyleSheet(f"""
+                background-color: {accent_color}20;  /* 20% opacity */
+                border-radius: 25px;
+                border: none;
+            """)
+            
+            icon_layout = QHBoxLayout(icon_container)
+            icon_layout.setContentsMargins(0, 0, 0, 0)
+            
+            icon_label = QLabel()
+            icon = QIcon.fromTheme(icon_name)
+            icon_pixmap = icon.pixmap(QSize(24, 24))
+            icon_label.setPixmap(icon_pixmap)
+            icon_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+            icon_layout.addWidget(icon_label)
+            
+            card_layout.addWidget(icon_container)
+            
+            # Add text section
+            text_layout = QVBoxLayout()
+            text_layout.setSpacing(4)
+            text_layout.setContentsMargins(12, 0, 0, 0)
+            
+            # Add title
+            title_label = QLabel(title)
+            title_font = QFont()
+            title_font.setBold(True)
+            title_font.setPointSize(12)
+            title_label.setFont(title_font)
+            text_layout.addWidget(title_label)
+            
+            # Add description
+            desc_label = QLabel(description)
+            desc_label.setWordWrap(True)
+            desc_label.setStyleSheet("color: #7F8C8D; font-size: 11px;")
+            text_layout.addWidget(desc_label)
+            
+            card_layout.addLayout(text_layout, 1)
+            
+            # Add arrow icon to suggest clickable
+            arrow_label = QLabel("→")
+            arrow_label.setStyleSheet(f"color: {accent_color}; font-size: 16px; font-weight: bold;")
+            card_layout.addWidget(arrow_label)
+            
+            # Connect click event
+            container.mousePressEvent = lambda e: self.handle_load_option(dialog, option_type)
+            
+            # Apply hover animations
+            container = create_hover_animations(container)
+            
+            return container
+        
+        # Database option
+        db_option = create_option_button(
+            "Database",
+            "Load SQL database files (SQLite, etc.) to query and analyze.",
+            "database",
+            "database",
+            "#2980B9"  # Blue accent
+        )
+        options_layout.addWidget(db_option)
+        
+        # Files option
+        files_option = create_option_button(
+            "Data Files", 
+            "Load Excel, CSV, Parquet and other data file formats.",
+            "document-new",
+            "files",
+            "#27AE60"  # Green accent
+        )
+        options_layout.addWidget(files_option)
+        
+        # Delta Table option
+        delta_option = create_option_button(
+            "Delta Table",
+            "Load data from Delta Lake format directories.",
+            "folder-open",
+            "delta",
+            "#8E44AD"  # Purple accent
+        )
+        options_layout.addWidget(delta_option)
+        
+        # Test Data option
+        test_option = create_option_button(
+            "Test Data",
+            "Generate and load sample data for testing and exploration.",
+            "system-run",
+            "test",
+            "#E67E22"  # Orange accent
+        )
+        options_layout.addWidget(test_option)
+        
+        layout.addLayout(options_layout)
+        
+        # Add spacer
+        layout.addStretch()
+        
+        # Add separator line before buttons
+        bottom_separator = QFrame()
+        bottom_separator.setFrameShape(QFrame.Shape.HLine)
+        bottom_separator.setFrameShadow(QFrame.Shadow.Sunken)
+        bottom_separator.setStyleSheet("background-color: #E0E0E0; min-height: 1px; max-height: 1px;")
+        layout.addWidget(bottom_separator)
+        
+        # Add cancel button
+        button_layout = QHBoxLayout()
+        button_layout.setSpacing(12)
+        button_layout.setContentsMargins(0, 16, 0, 0)
+        button_layout.addStretch()
+        
+        cancel_btn = QPushButton("Cancel")
+        cancel_btn.setFixedWidth(100)
+        cancel_btn.setStyleSheet("""
+            background-color: #F5F5F5;
+            border: 1px solid #E0E0E0;
+            border-radius: 6px;
+            padding: 8px 16px;
+            color: #7F8C8D;
+            font-weight: bold;
+        """)
+        cancel_btn.clicked.connect(dialog.reject)
+        button_layout.addWidget(cancel_btn)
+        
+        layout.addLayout(button_layout)
+        
+        # Apply modern drop shadow effect to the dialog
+        try:
+            dialog.setGraphicsEffect(None)  # Clear any existing effects
+            shadow = QGraphicsDropShadowEffect(dialog)
+            shadow.setBlurRadius(20)
+            shadow.setColor(QColor(0, 0, 0, 50))  # Semi-transparent black
+            shadow.setOffset(0, 0)
+            dialog.setGraphicsEffect(shadow)
+        except Exception:
+            pass  # Skip shadow if there are any issues
+        
+        # Add custom styling to make the dialog look modern
+        dialog.setStyleSheet("""
+            QDialog {
+                background-color: #FFFFFF;
+                border-radius: 12px;
+            }
+            QLabel {
+                color: #2C3E50;
+            }
+        """)
+        
+        # Store dialog animation references in the instance to prevent garbage collection
+        dialog._animations = animations
+        
+        # Center the dialog on the parent window
+        if self.geometry().isValid():
+            dialog.move(
+                self.geometry().center().x() - dialog.width() // 2,
+                self.geometry().center().y() - dialog.height() // 2
+            )
+        
+        # Show the dialog
+        dialog.exec()
+    
+    def handle_load_option(self, dialog, option):
+        """Handle the selected load option"""
+        # Close the dialog
+        dialog.accept()
+        
+        # Call the appropriate function based on the selected option
+        if option == "database":
+            self.open_database()
+        elif option == "files":
+            self.browse_files()
+        elif option == "delta":
+            self.load_delta_table()
+        elif option == "test":
+            self.load_test_data()
+
+    def analyze_table_entropy(self, table_name):
+        """Analyze a table with the entropy profiler to identify important columns"""
+        try:
+            # Show a loading indicator
+            self.statusBar().showMessage(f'Analyzing table "{table_name}" columns...')
+            
+            # Get the table data
+            if table_name in self.db_manager.loaded_tables:
+                # Check if table needs reloading first
+                if table_name in self.tables_list.tables_needing_reload:
+                    # Reload the table immediately
+                    self.reload_selected_table(table_name)
+                
+                # Get the data as a dataframe
+                query = f'SELECT * FROM "{table_name}"'
+                df = self.db_manager.execute_query(query)
+                
+                if df is not None and not df.empty:
+                    # Import the entropy profiler
+                    from sqlshell.utils.profile_entropy import visualize_profile
+                    
+                    # Create and show the visualization
+                    self.statusBar().showMessage(f'Generating entropy profile for "{table_name}"...')
+                    vis = visualize_profile(df)
+                    
+                    # Store a reference to prevent garbage collection
+                    self._entropy_window = vis
+                    
+                    self.statusBar().showMessage(f'Entropy profile generated for "{table_name}"')
+                else:
+                    QMessageBox.warning(self, "Empty Table", f"Table '{table_name}' has no data to analyze.")
+                    self.statusBar().showMessage(f'Table "{table_name}" is empty - cannot analyze')
+            else:
+                QMessageBox.warning(self, "Table Not Found", f"Table '{table_name}' not found.")
+                self.statusBar().showMessage(f'Table "{table_name}" not found')
+                
+        except Exception as e:
+            QMessageBox.critical(self, "Analysis Error", f"Error analyzing table:\n\n{str(e)}")
+            self.statusBar().showMessage(f'Error analyzing table: {str(e)}')
+            
+    def profile_table_structure(self, table_name):
+        """Analyze a table's structure to identify candidate keys and functional dependencies"""
+        try:
+            # Show a loading indicator
+            self.statusBar().showMessage(f'Profiling table structure for "{table_name}"...')
+            
+            # Get the table data
+            if table_name in self.db_manager.loaded_tables:
+                # Check if table needs reloading first
+                if table_name in self.tables_list.tables_needing_reload:
+                    # Reload the table immediately
+                    self.reload_selected_table(table_name)
+                
+                # Get the data as a dataframe
+                query = f'SELECT * FROM "{table_name}"'
+                df = self.db_manager.execute_query(query)
+                
+                if df is not None and not df.empty:
+                    # Import the key profiler
+                    from sqlshell.utils.profile_keys import visualize_profile
+                    
+                    # Create and show the visualization
+                    self.statusBar().showMessage(f'Generating table profile for "{table_name}"...')
+                    vis = visualize_profile(df)
+                    
+                    # Store a reference to prevent garbage collection
+                    self._keys_profile_window = vis
+                    
+                    self.statusBar().showMessage(f'Table structure profile generated for "{table_name}"')
+                else:
+                    QMessageBox.warning(self, "Empty Table", f"Table '{table_name}' has no data to analyze.")
+                    self.statusBar().showMessage(f'Table "{table_name}" is empty - cannot analyze')
+            else:
+                QMessageBox.warning(self, "Table Not Found", f"Table '{table_name}' not found.")
+                self.statusBar().showMessage(f'Table "{table_name}" not found')
+                
+        except Exception as e:
+            QMessageBox.critical(self, "Profile Error", f"Error profiling table structure:\n\n{str(e)}")
+            self.statusBar().showMessage(f'Error profiling table: {str(e)}')
+
 def main():
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='SQL Shell - SQL Query Tool')
+    parser.add_argument('--no-auto-load', action='store_true', 
+                        help='Disable auto-loading the most recent project at startup')
+    args = parser.parse_args()
+    
     app = QApplication(sys.argv)
     app.setStyle(QStyleFactory.create('Fusion'))
     
@@ -2358,6 +3264,10 @@ def main():
         print("Initializing main application...")
         window = SQLShell()
         
+        # Override auto-load setting if command-line argument is provided
+        if args.no_auto_load:
+            window.auto_load_recent_project = False
+            
         # Define the function to show main window and hide splash
         def show_main_window():
             # Properly finish the splash screen