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

sqlshell/main.py

@@ -7,8 +7,6 @@ if __name__ == "__main__":
     project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
     sys.path.insert(0, project_root)
 
-import duckdb
-import sqlite3
 import pandas as pd
 from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout,
                            QHBoxLayout, QTextEdit, QPushButton, QFileDialog,
@@ -16,10 +14,10 @@ from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout,
                            QTableWidgetItem, QHeaderView, QMessageBox, QPlainTextEdit,
                            QCompleter, QFrame, QToolButton, QSizePolicy, QTabWidget,
                            QStyleFactory, QToolBar, QStatusBar, QLineEdit, QMenu,
-                           QCheckBox, QWidgetAction, QMenuBar, QInputDialog,
-                           QStyledItemDelegate)
-from PyQt6.QtCore import Qt, QAbstractTableModel, QRegularExpression, QRect, QSize, QStringListModel, QPropertyAnimation, QEasingCurve, QTimer, QPoint
-from PyQt6.QtGui import QFont, QColor, QSyntaxHighlighter, QTextCharFormat, QPainter, QTextFormat, QTextCursor, QIcon, QPalette, QLinearGradient, QBrush, QPixmap, QPolygon, QPainterPath
+                           QCheckBox, QWidgetAction, QMenuBar, QInputDialog, QProgressDialog,
+                           QListWidgetItem)
+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
 from datetime import datetime
 
@@ -27,459 +25,128 @@ from sqlshell import create_test_data
 from sqlshell.splash_screen import AnimatedSplashScreen
 from sqlshell.syntax_highlighter import SQLSyntaxHighlighter
 from sqlshell.editor import LineNumberArea, SQLEditor
+from sqlshell.ui import FilterHeader, BarChartDelegate
+from sqlshell.db import DatabaseManager
+from sqlshell.query_tab import QueryTab
 
-class BarChartDelegate(QStyledItemDelegate):
+class DraggableTablesList(QListWidget):
+    """Custom QListWidget that provides better drag functionality for table names."""
+    
     def __init__(self, parent=None):
         super().__init__(parent)
-        self.min_val = 0
-        self.max_val = 1
-        self.bar_color = QColor("#3498DB")
-
-    def set_range(self, min_val, max_val):
-        self.min_val = min_val
-        self.max_val = max_val
-
-    def paint(self, painter, option, index):
-        # Draw the default background
-        super().paint(painter, option, index)
+        self.parent = parent
+        self.setDragEnabled(True)
+        self.setDragDropMode(QListWidget.DragDropMode.DragOnly)
         
-        try:
-            text = index.data()
-            value = float(text.replace(',', ''))
-            
-            # Calculate normalized value
-            range_val = self.max_val - self.min_val if self.max_val != self.min_val else 1
-            normalized = (value - self.min_val) / range_val
-            
-            # Define bar dimensions
-            bar_height = 16
-            max_bar_width = 100
-            bar_width = max(5, int(max_bar_width * normalized))
-            
-            # Calculate positions
-            text_width = option.fontMetrics.horizontalAdvance(text) + 10
-            bar_x = option.rect.left() + text_width + 10
-            bar_y = option.rect.center().y() - bar_height // 2
-            
-            # Draw the bar
-            bar_rect = QRect(bar_x, bar_y, bar_width, bar_height)
-            painter.fillRect(bar_rect, self.bar_color)
-            
-            # Draw the text
-            text_rect = QRect(option.rect.left() + 4, option.rect.top(),
-                            text_width, option.rect.height())
-            painter.drawText(text_rect, Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter, text)
-            
-        except (ValueError, AttributeError):
-            # If not a number, just draw the text
-            super().paint(painter, option, index)
-
-class FilterHeader(QHeaderView):
-    def __init__(self, parent=None):
-        super().__init__(Qt.Orientation.Horizontal, parent)
-        self.filter_buttons = []
-        self.active_filters = {}  # Track active filters for each column
-        self.columns_with_bars = set()  # Track which columns show bar charts
-        self.bar_delegates = {}  # Store delegates for columns with bars
-        self.setSectionsClickable(True)
-        self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
-        self.customContextMenuRequested.connect(self.show_header_context_menu)
-        self.main_window = None  # Store reference to main window
-        self.filter_icon_color = QColor("#3498DB")  # Bright blue color for filter icon
-
-    def toggle_bar_chart(self, column_index):
-        """Toggle bar chart visualization for a column"""
-        table = self.parent()
-        if not table:
-            return
-
-        if column_index in self.columns_with_bars:
-            # Remove bars
-            self.columns_with_bars.remove(column_index)
-            if column_index in self.bar_delegates:
-                table.setItemDelegateForColumn(column_index, None)
-                del self.bar_delegates[column_index]
-        else:
-            # Add bars
-            self.columns_with_bars.add(column_index)
-            
-            # Get all values for normalization
-            values = []
-            for row in range(table.rowCount()):
-                item = table.item(row, column_index)
-                if item:
-                    try:
-                        value = float(item.text().replace(',', ''))
-                        values.append(value)
-                    except ValueError:
-                        continue
-
-            if not values:
-                return
-
-            # Calculate min and max for normalization
-            min_val = min(values)
-            max_val = max(values)
-            
-            # Create and set up delegate
-            delegate = BarChartDelegate(table)
-            delegate.set_range(min_val, max_val)
-            self.bar_delegates[column_index] = delegate
-            table.setItemDelegateForColumn(column_index, delegate)
-
-        # Update the view
-        table.viewport().update()
-
-    def show_header_context_menu(self, pos):
-        """Show context menu for header section"""
-        logical_index = self.logicalIndexAt(pos)
-        if logical_index < 0:
-            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;
-            }
-        """)
-
-        # Add sort actions
-        sort_asc_action = context_menu.addAction("Sort Ascending")
-        sort_desc_action = context_menu.addAction("Sort Descending")
-        context_menu.addSeparator()
-        filter_action = context_menu.addAction("Filter...")
-        
-        # Add bar chart action if column is numeric
-        table = self.parent()
-        if table and table.rowCount() > 0:
-            try:
-                # Check if column contains numeric values
-                sample_value = table.item(0, logical_index).text()
-                float(sample_value.replace(',', ''))  # Try converting to float
-                
-                context_menu.addSeparator()
-                toggle_bar_action = context_menu.addAction(
-                    "Remove Bar Chart" if logical_index in self.columns_with_bars 
-                    else "Add Bar Chart"
-                )
-            except (ValueError, AttributeError):
-                toggle_bar_action = None
-        else:
-            toggle_bar_action = None
-
-        # Show menu and get selected action
-        action = context_menu.exec(self.mapToGlobal(pos))
-
-        if not action:
-            return
-
-        table = self.parent()
-        if not table:
-            return
-
-        if action == sort_asc_action:
-            table.sortItems(logical_index, Qt.SortOrder.AscendingOrder)
-        elif action == sort_desc_action:
-            table.sortItems(logical_index, Qt.SortOrder.DescendingOrder)
-        elif action == filter_action:
-            self.show_filter_menu(logical_index)
-        elif action == toggle_bar_action:
-            self.toggle_bar_chart(logical_index)
-
-    def set_main_window(self, window):
-        """Set the reference to the main window"""
-        self.main_window = window
-        
-    def paintSection(self, painter, rect, logical_index):
-        """Override paint section to add filter indicator"""
-        super().paintSection(painter, rect, logical_index)
-        
-        if logical_index in self.active_filters:
-            # Draw background highlight for filtered columns
-            highlight_color = QColor(52, 152, 219, 30)  # Light blue background
-            painter.fillRect(rect, highlight_color)
-            
-            # Make icon larger and more visible
-            icon_size = min(rect.height() - 8, 24)  # Larger icon, but not too large
-            margin = 6
-            icon_rect = QRect(
-                rect.right() - icon_size - margin,
-                rect.top() + (rect.height() - icon_size) // 2,
-                icon_size,
-                icon_size
-            )
-            
-            # Draw filter icon with improved visibility
-            painter.save()
-            
-            # Set up the pen for better visibility
-            pen = painter.pen()
-            pen.setWidth(3)  # Thicker lines
-            pen.setColor(self.filter_icon_color)
-            painter.setPen(pen)
-            
-            # Calculate points for larger funnel shape
-            points = [
-                QPoint(icon_rect.left(), icon_rect.top()),
-                QPoint(icon_rect.right(), icon_rect.top()),
-                QPoint(icon_rect.center().x() + icon_size//3, icon_rect.center().y()),
-                QPoint(icon_rect.center().x() + icon_size//3, icon_rect.bottom()),
-                QPoint(icon_rect.center().x() - icon_size//3, icon_rect.bottom()),
-                QPoint(icon_rect.center().x() - icon_size//3, icon_rect.center().y()),
-                QPoint(icon_rect.left(), icon_rect.top())
-            ]
-            
-            # Create and fill path
-            path = QPainterPath()
-            path.moveTo(float(points[0].x()), float(points[0].y()))
-            for point in points[1:]:
-                path.lineTo(float(point.x()), float(point.y()))
-            
-            # Fill with semi-transparent blue
-            painter.fillPath(path, QBrush(QColor(52, 152, 219, 120)))  # More opaque fill
-            
-            # Draw outline
-            painter.drawPolyline(QPolygon(points))
-            
-            # If multiple values are filtered, add a number
-            if len(self.active_filters[logical_index]) > 1:
-                # Draw number with better visibility
-                number_rect = QRect(icon_rect.left(), icon_rect.top(),
-                                  icon_rect.width(), icon_rect.height())
-                painter.setFont(QFont("Arial", icon_size//2, QFont.Weight.Bold))
-                
-                # Draw text shadow for better contrast
-                painter.setPen(QColor("white"))
-                painter.drawText(number_rect.adjusted(1, 1, 1, 1),
-                               Qt.AlignmentFlag.AlignCenter,
-                               str(len(self.active_filters[logical_index])))
-                
-                # Draw main text
-                painter.setPen(self.filter_icon_color)
-                painter.drawText(number_rect, Qt.AlignmentFlag.AlignCenter,
-                               str(len(self.active_filters[logical_index])))
-            
-            painter.restore()
-            
-            # Draw a more visible indicator at the bottom of the header section
-            painter.save()
-            indicator_height = 3  # Thicker indicator line
-            indicator_rect = QRect(rect.left(), rect.bottom() - indicator_height,
-                                 rect.width(), indicator_height)
-            painter.fillRect(indicator_rect, self.filter_icon_color)
-            painter.restore()
-        
-    def show_filter_menu(self, logical_index):
-        if not self.parent() or not isinstance(self.parent(), QTableWidget):
-            return
-            
-        table = self.parent()
-        unique_values = set()
-        
-        # Collect unique values from the column
-        for row in range(table.rowCount()):
-            item = table.item(row, logical_index)
-            if item and not table.isRowHidden(row):
-                unique_values.add(item.text())
-        
-        # Create and show the filter menu
-        menu = QMenu(self)
-        menu.setStyleSheet("""
-            QMenu {
-                background-color: white;
-                border: 1px solid #BDC3C7;
-                padding: 5px;
-            }
-            QMenu::item {
-                padding: 5px 20px;
-            }
-            QMenu::item:selected {
-                background-color: #3498DB;
-                color: white;
-            }
-            QCheckBox {
-                padding: 5px;
-            }
-            QScrollArea {
+        # Apply custom styling
+        self.setStyleSheet("""
+            QListWidget {
+                background-color: rgba(255, 255, 255, 0.1);
                 border: none;
-            }
-        """)
-        
-        # Add search box at the top
-        search_widget = QWidget(menu)
-        search_layout = QVBoxLayout(search_widget)
-        search_edit = QLineEdit(search_widget)
-        search_edit.setPlaceholderText("Search values...")
-        search_layout.addWidget(search_edit)
-        
-        # Add action for search widget
-        search_action = QWidgetAction(menu)
-        search_action.setDefaultWidget(search_widget)
-        menu.addAction(search_action)
-        menu.addSeparator()
-        
-        # Add "Select All" checkbox
-        select_all = QCheckBox("Select All", menu)
-        select_all.setChecked(True)
-        select_all_action = QWidgetAction(menu)
-        select_all_action.setDefaultWidget(select_all)
-        menu.addAction(select_all_action)
-        menu.addSeparator()
-        
-        # Create scrollable area for checkboxes
-        scroll_widget = QWidget(menu)
-        scroll_layout = QVBoxLayout(scroll_widget)
-        scroll_layout.setSpacing(2)
-        scroll_layout.setContentsMargins(0, 0, 0, 0)
-        
-        # Add checkboxes for unique values
-        value_checkboxes = {}
-        for value in sorted(unique_values):
-            checkbox = QCheckBox(str(value), scroll_widget)
-            # Set checked state based on active filters
-            checkbox.setChecked(logical_index not in self.active_filters or 
-                              value in self.active_filters[logical_index])
-            value_checkboxes[value] = checkbox
-            scroll_layout.addWidget(checkbox)
-        
-        # Add scrollable area to menu
-        scroll_action = QWidgetAction(menu)
-        scroll_action.setDefaultWidget(scroll_widget)
-        menu.addAction(scroll_action)
-        
-        # Connect search box to filter checkboxes
-        def filter_checkboxes(text):
-            for value, checkbox in value_checkboxes.items():
-                checkbox.setVisible(text.lower() in str(value).lower())
-        
-        search_edit.textChanged.connect(filter_checkboxes)
-        
-        # Connect select all to other checkboxes
-        def toggle_all(state):
-            for checkbox in value_checkboxes.values():
-                if not checkbox.isHidden():  # Only toggle visible checkboxes
-                    checkbox.setChecked(state)
-        
-        select_all.stateChanged.connect(toggle_all)
-        
-        # Add Apply and Clear buttons
-        menu.addSeparator()
-        apply_button = QPushButton("Apply Filter", menu)
-        apply_button.setStyleSheet("""
-            QPushButton {
-                background-color: #2ECC71;
+                border-radius: 4px;
                 color: white;
-                border: none;
-                padding: 5px 15px;
-                border-radius: 3px;
             }
-            QPushButton:hover {
-                background-color: #27AE60;
-            }
-        """)
-        
-        clear_button = QPushButton("Clear Filter", menu)
-        clear_button.setStyleSheet("""
-            QPushButton {
-                background-color: #E74C3C;
-                color: white;
-                border: none;
-                padding: 5px 15px;
-                border-radius: 3px;
+            QListWidget::item:selected {
+                background-color: rgba(255, 255, 255, 0.2);
             }
-            QPushButton:hover {
-                background-color: #C0392B;
+            QListWidget::item:hover:!selected {
+                background-color: rgba(255, 255, 255, 0.1);
             }
         """)
         
-        button_widget = QWidget(menu)
-        button_layout = QHBoxLayout(button_widget)
-        button_layout.addWidget(apply_button)
-        button_layout.addWidget(clear_button)
-        
-        button_action = QWidgetAction(menu)
-        button_action.setDefaultWidget(button_widget)
-        menu.addAction(button_action)
-        
-        def apply_filter():
-            # Get selected values
-            selected_values = {value for value, checkbox in value_checkboxes.items() 
-                             if checkbox.isChecked()}
+    def startDrag(self, supportedActions):
+        """Override startDrag to customize the drag data."""
+        item = self.currentItem()
+        if not item:
+            return
             
-            if len(selected_values) < len(unique_values):
-                # Store active filter only if not all values are selected
-                self.active_filters[logical_index] = selected_values
-            else:
-                # Remove filter if all values are selected
-                self.active_filters.pop(logical_index, None)
-            
-            # Apply all active filters
-            self.apply_all_filters(table)
-            
-            menu.close()
-            self.updateSection(logical_index)  # Redraw section to show/hide filter icon
-        
-        def clear_filter():
-            # Remove filter for this column
-            if logical_index in self.active_filters:
-                del self.active_filters[logical_index]
-            
-            # Apply remaining filters
-            self.apply_all_filters(table)
-            
-            menu.close()
-            self.updateSection(logical_index)  # Redraw section to hide filter icon
-        
-        apply_button.clicked.connect(apply_filter)
-        clear_button.clicked.connect(clear_filter)
-        
-        # Show menu under the header section
-        header_pos = self.mapToGlobal(self.geometry().bottomLeft())
-        header_pos.setX(header_pos.x() + self.sectionPosition(logical_index))
-        menu.exec(header_pos)
-        
-    def apply_all_filters(self, table):
-        """Apply all active filters to the table"""
-        # Show all rows first
-        for row in range(table.rowCount()):
-            table.setRowHidden(row, False)
-        
-        # Apply each active filter
-        for col_idx, allowed_values in self.active_filters.items():
-            for row in range(table.rowCount()):
-                item = table.item(row, col_idx)
-                if item and not table.isRowHidden(row):
-                    table.setRowHidden(row, item.text() not in allowed_values)
-        
-        # Update status bar with visible row count
-        if self.main_window:
-            visible_rows = sum(1 for row in range(table.rowCount()) 
-                             if not table.isRowHidden(row))
-            total_filters = len(self.active_filters)
-            filter_text = f" ({total_filters} filter{'s' if total_filters != 1 else ''} active)" if total_filters > 0 else ""
-            self.main_window.statusBar().showMessage(
-                f"Showing {visible_rows:,} rows{filter_text}")
+        # 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))
 
 class SQLShell(QMainWindow):
     def __init__(self):
         super().__init__()
-        self.conn = None
-        self.current_connection_type = None
-        self.loaded_tables = {}  # Keep track of loaded tables
-        self.table_columns = {}  # Keep track of table columns
+        self.db_manager = DatabaseManager()
         self.current_df = None  # Store the current DataFrame for filtering
         self.filter_widgets = []  # Store filter line edits
         self.current_project_file = None  # Store the current project file path
+        self.recent_projects = []  # Store list of recent projects
+        self.max_recent_projects = 10  # Maximum number of recent projects to track
+        self.tabs = []  # Store list of all tabs
+        
+        # Load recent projects from settings
+        self.load_recent_projects()
         
         # Define color scheme
         self.colors = {
@@ -499,6 +166,9 @@ class SQLShell(QMainWindow):
         
         self.init_ui()
         self.apply_stylesheet()
+        
+        # Create initial tab
+        self.add_tab()
 
     def apply_stylesheet(self):
         """Apply custom stylesheet to the application"""
@@ -643,6 +313,44 @@ class SQLShell(QMainWindow):
                 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;
@@ -657,7 +365,39 @@ class SQLShell(QMainWindow):
 
     def init_ui(self):
         self.setWindowTitle('SQL Shell')
-        self.setGeometry(100, 100, 1400, 800)
+        
+        # Get screen geometry for smart sizing
+        screen = QApplication.primaryScreen()
+        screen_geometry = screen.availableGeometry()
+        screen_width = screen_geometry.width()
+        screen_height = screen_geometry.height()
+        
+        # Calculate adaptive window size based on screen size
+        # Use 85% of screen size for larger screens, fixed size for smaller screens
+        if screen_width >= 1920 and screen_height >= 1080:  # Larger screens
+            window_width = int(screen_width * 0.85)
+            window_height = int(screen_height * 0.85)
+            self.setGeometry(
+                (screen_width - window_width) // 2,  # Center horizontally
+                (screen_height - window_height) // 2,  # Center vertically
+                window_width, 
+                window_height
+            )
+        else:  # Default for smaller screens
+            self.setGeometry(100, 100, 1400, 800)
+        
+        # Remember if the window was maximized
+        self.was_maximized = False
+        
+        # Set application icon
+        icon_path = os.path.join(os.path.dirname(__file__), "resources", "icon.png")
+        if os.path.exists(icon_path):
+            self.setWindowIcon(QIcon(icon_path))
+        else:
+            # Fallback to the main logo if the icon isn't found
+            main_logo_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "sqlshell_logo.png")
+            if os.path.exists(main_logo_path):
+                self.setWindowIcon(QIcon(main_logo_path))
         
         # Create menu bar
         menubar = self.menuBar()
@@ -672,6 +412,10 @@ class SQLShell(QMainWindow):
         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)
@@ -686,6 +430,48 @@ class SQLShell(QMainWindow):
         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))
+        
+        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)
+        
         # Create custom status bar
         status_bar = QStatusBar()
         self.setStatusBar(status_bar)
@@ -755,21 +541,7 @@ class SQLShell(QMainWindow):
         left_layout.addLayout(table_actions_layout)
         
         # Tables list with custom styling
-        self.tables_list = QListWidget()
-        self.tables_list.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);
-            }
-        """)
+        self.tables_list = DraggableTablesList()
         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)
@@ -778,7 +550,7 @@ class SQLShell(QMainWindow):
         # Add spacer at the bottom
         left_layout.addStretch()
         
-        # Right panel for query and results
+        # Right panel for query tabs and results
         right_panel = QFrame()
         right_panel.setObjectName("content_panel")
         right_layout = QVBoxLayout(right_panel)
@@ -790,143 +562,82 @@ class SQLShell(QMainWindow):
         query_header.setObjectName("header_label")
         right_layout.addWidget(query_header)
         
-        # Create splitter for query and results
-        splitter = QSplitter(Qt.Orientation.Vertical)
-        splitter.setHandleWidth(8)
-        splitter.setChildrenCollapsible(False)
-        
-        # Top part - Query section
-        query_widget = QFrame()
-        query_widget.setObjectName("content_panel")
-        query_layout = QVBoxLayout(query_widget)
-        query_layout.setContentsMargins(16, 16, 16, 16)
-        query_layout.setSpacing(12)
-        
-        # Query input
-        self.query_edit = SQLEditor()
-        # Apply syntax highlighting to the query editor
-        self.sql_highlighter = SQLSyntaxHighlighter(self.query_edit.document())
-        query_layout.addWidget(self.query_edit)
-        
-        # Button row
-        button_layout = QHBoxLayout()
-        button_layout.setSpacing(8)
-        
-        self.execute_btn = QPushButton('Execute Query')
-        self.execute_btn.setObjectName("primary_button")
-        self.execute_btn.setIcon(QIcon.fromTheme("media-playback-start"))
-        self.execute_btn.clicked.connect(self.execute_query)
-        self.execute_btn.setToolTip("Execute Query (Ctrl+Enter)")
-        
-        self.clear_btn = QPushButton('Clear')
-        self.clear_btn.setIcon(QIcon.fromTheme("edit-clear"))
-        self.clear_btn.clicked.connect(self.clear_query)
-        
-        button_layout.addWidget(self.execute_btn)
-        button_layout.addWidget(self.clear_btn)
-        button_layout.addStretch()
-        
-        query_layout.addLayout(button_layout)
-        
-        # Bottom part - Results section
-        results_widget = QFrame()
-        results_widget.setObjectName("content_panel")
-        results_layout = QVBoxLayout(results_widget)
-        results_layout.setContentsMargins(16, 16, 16, 16)
-        results_layout.setSpacing(12)
-        
-        # Results header with row count and export options
-        results_header_layout = QHBoxLayout()
-        
-        results_title = QLabel("RESULTS")
-        results_title.setObjectName("header_label")
-        
-        self.row_count_label = QLabel("")
-        self.row_count_label.setStyleSheet(f"color: {self.colors['text_light']}; font-style: italic;")
-        
-        results_header_layout.addWidget(results_title)
-        results_header_layout.addWidget(self.row_count_label)
-        results_header_layout.addStretch()
-        
-        # Export buttons
-        export_layout = QHBoxLayout()
-        export_layout.setSpacing(8)
-        
-        self.export_excel_btn = QPushButton('Export to Excel')
-        self.export_excel_btn.setIcon(QIcon.fromTheme("x-office-spreadsheet"))
-        self.export_excel_btn.clicked.connect(self.export_to_excel)
-        
-        self.export_parquet_btn = QPushButton('Export to Parquet')
-        self.export_parquet_btn.setIcon(QIcon.fromTheme("document-save"))
-        self.export_parquet_btn.clicked.connect(self.export_to_parquet)
-        
-        export_layout.addWidget(self.export_excel_btn)
-        export_layout.addWidget(self.export_parquet_btn)
-        
-        results_header_layout.addLayout(export_layout)
-        results_layout.addLayout(results_header_layout)
-        
-        # Table widget for results with modern styling
-        self.results_table = QTableWidget()
-        self.results_table.setSortingEnabled(True)
-        self.results_table.setAlternatingRowColors(True)
-        
-        # Set custom header for filtering
-        header = FilterHeader(self.results_table)
-        header.set_main_window(self)  # Set reference to main window
-        self.results_table.setHorizontalHeader(header)
-        header.setStretchLastSection(True)
-        header.setSectionsMovable(True)
-        
-        self.results_table.verticalHeader().setVisible(False)
-        self.results_table.setShowGrid(True)
-        self.results_table.setGridStyle(Qt.PenStyle.SolidLine)
-        self.results_table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Interactive)
-        
-        results_layout.addWidget(self.results_table)
-
-        # Add widgets to splitter
-        splitter.addWidget(query_widget)
-        splitter.addWidget(results_widget)
+        # Create tab widget for multiple queries
+        self.tab_widget = QTabWidget()
+        self.tab_widget.setTabsClosable(True)
+        self.tab_widget.setMovable(True)
+        self.tab_widget.tabCloseRequested.connect(self.close_tab)
+        
+        # Connect double-click signal for direct tab renaming
+        self.tab_widget.tabBarDoubleClicked.connect(self.handle_tab_double_click)
         
-        # Set initial sizes for splitter
-        splitter.setSizes([300, 500])
+        # Add a "+" button to the tab bar
+        self.tab_widget.setCornerWidget(self.create_tab_corner_widget())
         
-        right_layout.addWidget(splitter)
+        right_layout.addWidget(self.tab_widget)
 
         # Add panels to main layout
         main_layout.addWidget(left_panel, 1)
         main_layout.addWidget(right_panel, 4)
 
         # Status bar
-        self.statusBar().showMessage('Ready | Ctrl+Enter: Execute Query | Ctrl+K: Toggle Comment')
-        
-        # Show keyboard shortcuts in a tooltip for the query editor
-        self.query_edit.setToolTip(
-            "Keyboard Shortcuts:\n"
-            "Ctrl+Enter: Execute Query\n"
-            "Ctrl+K: Toggle Comment\n"
-            "Tab: Insert 4 spaces\n"
-            "Ctrl+Space: Show autocomplete"
-        )
+        self.statusBar().showMessage('Ready | Ctrl+Enter: Execute Query | Ctrl+K: Toggle Comment | Ctrl+T: New Tab')
+        
+    def create_tab_corner_widget(self):
+        """Create a corner widget with a + button to add new tabs"""
+        corner_widget = QWidget()
+        layout = QHBoxLayout(corner_widget)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+        
+        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.clicked.connect(self.add_tab)
+        
+        layout.addWidget(add_tab_btn)
+        return corner_widget
 
     def populate_table(self, df):
         """Populate the results table with DataFrame data using memory-efficient chunking"""
         try:
+            # Get the current tab
+            current_tab = self.get_current_tab()
+            if not current_tab:
+                return
+                
             # Store the current DataFrame for filtering
-            self.current_df = df.copy()
+            current_tab.current_df = df.copy()
+            self.current_df = df.copy()  # Keep this for compatibility with existing code
             
             # Remember which columns had bar charts
-            header = self.results_table.horizontalHeader()
+            header = current_tab.results_table.horizontalHeader()
             if isinstance(header, FilterHeader):
                 columns_with_bars = header.columns_with_bars.copy()
             else:
                 columns_with_bars = set()
             
             # Clear existing data
-            self.results_table.clearContents()
-            self.results_table.setRowCount(0)
-            self.results_table.setColumnCount(0)
+            current_tab.results_table.clearContents()
+            current_tab.results_table.setRowCount(0)
+            current_tab.results_table.setColumnCount(0)
             
             if df.empty:
                 self.statusBar().showMessage("Query returned no results")
@@ -935,11 +646,11 @@ class SQLShell(QMainWindow):
             # Set up the table dimensions
             row_count = len(df)
             col_count = len(df.columns)
-            self.results_table.setColumnCount(col_count)
+            current_tab.results_table.setColumnCount(col_count)
             
             # Set column headers
             headers = [str(col) for col in df.columns]
-            self.results_table.setHorizontalHeaderLabels(headers)
+            current_tab.results_table.setHorizontalHeaderLabels(headers)
             
             # Calculate chunk size (adjust based on available memory)
             CHUNK_SIZE = 1000
@@ -950,27 +661,30 @@ class SQLShell(QMainWindow):
                 chunk = df.iloc[chunk_start:chunk_end]
                 
                 # Add rows for this chunk
-                self.results_table.setRowCount(chunk_end)
+                current_tab.results_table.setRowCount(chunk_end)
                 
                 for row_idx, (_, row_data) in enumerate(chunk.iterrows(), start=chunk_start):
                     for col_idx, value in enumerate(row_data):
                         formatted_value = self.format_value(value)
                         item = QTableWidgetItem(formatted_value)
-                        self.results_table.setItem(row_idx, col_idx, item)
+                        current_tab.results_table.setItem(row_idx, col_idx, item)
                         
                 # Process events to keep UI responsive
                 QApplication.processEvents()
             
             # Optimize column widths
-            self.results_table.resizeColumnsToContents()
+            current_tab.results_table.resizeColumnsToContents()
             
             # Restore bar charts for columns that previously had them
-            header = self.results_table.horizontalHeader()
+            header = current_tab.results_table.horizontalHeader()
             if isinstance(header, FilterHeader):
                 for col_idx in columns_with_bars:
                     if col_idx < col_count:  # Only if column still exists
                         header.toggle_bar_chart(col_idx)
             
+            # Update row count label
+            current_tab.row_count_label.setText(f"{row_count:,} rows")
+            
             # Update status
             memory_usage = df.memory_usage(deep=True).sum() / (1024 * 1024)  # Convert to MB
             self.statusBar().showMessage(
@@ -1041,11 +755,10 @@ class SQLShell(QMainWindow):
         return str(value)
 
     def browse_files(self):
-        if not self.conn:
+        if not self.db_manager.is_connected():
             # Create a default in-memory DuckDB connection if none exists
-            self.conn = duckdb.connect(':memory:')
-            self.current_connection_type = 'duckdb'
-            self.db_info_label.setText("Connected to: in-memory DuckDB")
+            connection_info = self.db_manager.create_memory_connection()
+            self.db_info_label.setText(connection_info)
             
         file_names, _ = QFileDialog.getOpenFileNames(
             self,
@@ -1056,38 +769,8 @@ class SQLShell(QMainWindow):
         
         for file_name in file_names:
             try:
-                if file_name.endswith(('.xlsx', '.xls')):
-                    df = pd.read_excel(file_name)
-                elif file_name.endswith('.csv'):
-                    df = pd.read_csv(file_name)
-                elif file_name.endswith('.parquet'):
-                    df = pd.read_parquet(file_name)
-                else:
-                    raise ValueError("Unsupported file format")
-                
-                # Generate table name from file name
-                base_name = os.path.splitext(os.path.basename(file_name))[0]
-                table_name = self.sanitize_table_name(base_name)
-                
-                # Ensure unique table name
-                original_name = table_name
-                counter = 1
-                while table_name in self.loaded_tables:
-                    table_name = f"{original_name}_{counter}"
-                    counter += 1
-                
-                # Handle table creation based on database type
-                if self.current_connection_type == 'sqlite':
-                    # For SQLite, create a table from the DataFrame
-                    df.to_sql(table_name, self.conn, index=False, if_exists='replace')
-                else:
-                    # For DuckDB, register the DataFrame as a view
-                    self.conn.register(table_name, df)
-                
-                self.loaded_tables[table_name] = file_name
-                
-                # Store column names
-                self.table_columns[table_name] = df.columns.tolist()
+                # 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)})")
@@ -1113,26 +796,11 @@ class SQLShell(QMainWindow):
                 self.results_table.setColumnCount(0)
                 self.row_count_label.setText("")
 
-    def sanitize_table_name(self, name):
-        # Replace invalid characters with underscores
-        import re
-        name = re.sub(r'[^a-zA-Z0-9_]', '_', name)
-        # Ensure it starts with a letter
-        if not name[0].isalpha():
-            name = 'table_' + name
-        return name.lower()
-
     def remove_selected_table(self):
         current_item = self.tables_list.currentItem()
         if current_item:
             table_name = current_item.text().split(' (')[0]
-            if table_name in self.loaded_tables:
-                # Remove from DuckDB
-                self.conn.execute(f'DROP VIEW IF EXISTS {table_name}')
-                # Remove from our tracking
-                del self.loaded_tables[table_name]
-                if table_name in self.table_columns:
-                    del self.table_columns[table_name]
+            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}"')
@@ -1146,15 +814,6 @@ class SQLShell(QMainWindow):
     def open_database(self):
         """Open a database connection with proper error handling and resource management"""
         try:
-            if self.conn:
-                # Close existing connection before opening new one
-                if self.current_connection_type == "duckdb":
-                    self.conn.close()
-                else:  # sqlite
-                    self.conn.close()
-                self.conn = None
-                self.current_connection_type = None
-            
             filename, _ = QFileDialog.getOpenFileName(
                 self,
                 "Open Database",
@@ -1163,86 +822,214 @@ class SQLShell(QMainWindow):
             )
             
             if filename:
-                if self.is_sqlite_db(filename):
-                    self.conn = sqlite3.connect(filename)
-                    self.current_connection_type = "sqlite"
-                else:
-                    self.conn = duckdb.connect(filename)
-                    self.current_connection_type = "duckdb"
-                
-                self.load_database_tables()
-                self.statusBar().showMessage(f"Connected to database: {filename}")
-                
-        except (sqlite3.Error, duckdb.Error) as e:
-            QMessageBox.critical(self, "Database Connection Error",
-                f"Failed to open database:\n\n{str(e)}")
-            self.statusBar().showMessage("Failed to open database")
-            self.conn = None
-            self.current_connection_type = None
-
-    def is_sqlite_db(self, filename):
-        """Check if the file is a SQLite database"""
-        try:
-            with open(filename, 'rb') as f:
-                header = f.read(16)
-                return header[:16] == b'SQLite format 3\x00'
-        except:
-            return False
-
-    def load_database_tables(self):
-        """Load all tables from the current database"""
-        try:
-            if self.current_connection_type == 'sqlite':
-                query = "SELECT name FROM sqlite_master WHERE type='table'"
-                cursor = self.conn.cursor()
-                tables = cursor.execute(query).fetchall()
-                for (table_name,) in tables:
-                    self.loaded_tables[table_name] = 'database'
-                    self.tables_list.addItem(f"{table_name} (database)")
+                try:
+                    # 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)
                     
-                    # Get column names for each table
-                    try:
-                        column_query = f"PRAGMA table_info({table_name})"
-                        columns = cursor.execute(column_query).fetchall()
-                        self.table_columns[table_name] = [col[1] for col in columns]  # Column name is at index 1
-                    except Exception:
-                        self.table_columns[table_name] = []
-            else:  # duckdb
-                query = "SELECT table_name FROM information_schema.tables WHERE table_schema='main'"
-                result = self.conn.execute(query).fetchdf()
-                for table_name in result['table_name']:
-                    self.loaded_tables[table_name] = 'database'
-                    self.tables_list.addItem(f"{table_name} (database)")
+                    # Use the database manager to open the database
+                    self.db_manager.open_database(filename)
                     
-                    # Get column names for each table
-                    try:
-                        column_query = f"SELECT column_name FROM information_schema.columns WHERE table_name='{table_name}' AND table_schema='main'"
-                        columns = self.conn.execute(column_query).fetchdf()
-                        self.table_columns[table_name] = columns['column_name'].tolist()
-                    except Exception:
-                        self.table_columns[table_name] = []
-                        
-            # Update the completer with table and column names
-            self.update_completer()
+                    # 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)")
+                    
+                    # Update the completer with table and column names
+                    self.update_completer()
+                    
+                    # Update status bar
+                    self.statusBar().showMessage(f"Connected to database: {filename}")
+                    self.db_info_label.setText(self.db_manager.get_connection_info())
+                    
+                except Exception as e:
+                    QMessageBox.critical(self, "Database Connection Error",
+                        f"Failed to open database:\n\n{str(e)}")
+                    self.statusBar().showMessage("Failed to open database")
+                
         except Exception as e:
-            self.statusBar().showMessage(f'Error loading tables: {str(e)}')
+            QMessageBox.critical(self, "Error", 
+                f"Unexpected error:\n\n{str(e)}")
+            self.statusBar().showMessage("Error opening database")
 
     def update_completer(self):
-        """Update the completer with table and column names"""
-        # Collect all table names and column names
-        completion_words = list(self.loaded_tables.keys())
-        
-        # Add column names with table name prefix (for joins)
-        for table, columns in self.table_columns.items():
-            completion_words.extend(columns)
-            completion_words.extend([f"{table}.{col}" for col in columns])
+        """Update the completer with table and column names in a non-blocking way"""
+        try:
+            # Check if any tabs exist
+            if self.tab_widget.count() == 0:
+                return
+            
+            # Start a background update with a timer
+            self.statusBar().showMessage("Updating auto-completion...", 2000)
+            
+            # Track query history and frequently used terms
+            if not hasattr(self, 'query_history'):
+                self.query_history = []
+                self.completion_usage = {}  # Track usage frequency
+            
+            # Get completion words from the database manager
+            try:
+                completion_words = self.db_manager.get_all_table_columns()
+            except Exception as e:
+                self.statusBar().showMessage(f"Error getting completions: {str(e)}", 2000)
+                completion_words = []
+            
+            # Add frequently used terms from query history with higher priority
+            if hasattr(self, 'completion_usage') and self.completion_usage:
+                # Get the most frequently used terms (top 100)
+                frequent_terms = sorted(
+                    self.completion_usage.items(), 
+                    key=lambda x: x[1], 
+                    reverse=True
+                )[:100]
+                
+                # Add these to our completion words
+                for term, _ in frequent_terms:
+                    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
+            model = QStringListModel(completion_words)
             
-        # Update the completer in the query editor
-        self.query_edit.update_completer_model(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'):
+                    try:
+                        current_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)
+            
+            # 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:
-            query = self.query_edit.toPlainText().strip()
+            # Get the current tab
+            current_tab = self.get_current_tab()
+            if not current_tab:
+                return
+                
+            query = current_tab.get_query_text().strip()
             if not query:
                 QMessageBox.warning(self, "Empty Query", "Please enter a SQL query to execute.")
                 return
@@ -1250,29 +1037,24 @@ class SQLShell(QMainWindow):
             start_time = datetime.now()
             
             try:
-                if self.current_connection_type == "duckdb":
-                    result = self.conn.execute(query).fetchdf()
-                else:  # sqlite
-                    result = pd.read_sql_query(query, self.conn)
+                # Use the database manager to execute the query
+                result = self.db_manager.execute_query(query)
                 
                 execution_time = (datetime.now() - start_time).total_seconds()
                 self.populate_table(result)
                 self.statusBar().showMessage(f"Query executed successfully. Time: {execution_time:.2f}s. Rows: {len(result)}")
                 
-            except (duckdb.Error, sqlite3.Error) as e:
-                error_msg = str(e)
-                if "syntax error" in error_msg.lower():
-                    QMessageBox.critical(self, "SQL Syntax Error", 
-                        f"There is a syntax error in your query:\n\n{error_msg}")
-                elif "no such table" in error_msg.lower():
-                    QMessageBox.critical(self, "Table Not Found", 
-                        f"The referenced table does not exist:\n\n{error_msg}")
-                elif "no such column" in error_msg.lower():
-                    QMessageBox.critical(self, "Column Not Found", 
-                        f"The referenced column does not exist:\n\n{error_msg}")
-                else:
-                    QMessageBox.critical(self, "Database Error", 
-                        f"An error occurred while executing the query:\n\n{error_msg}")
+                # Record query in history and update completion usage
+                self._update_query_history(query)
+                
+            except SyntaxError as e:
+                QMessageBox.critical(self, "SQL Syntax Error", str(e))
+                self.statusBar().showMessage("Query execution failed: syntax error")
+            except ValueError as e:
+                QMessageBox.critical(self, "Query Error", str(e))
+                self.statusBar().showMessage("Query execution failed")
+            except Exception as e:
+                QMessageBox.critical(self, "Database Error", str(e))
                 self.statusBar().showMessage("Query execution failed")
                 
         except Exception as e:
@@ -1280,59 +1062,129 @@ class SQLShell(QMainWindow):
                 f"An unexpected error occurred:\n\n{str(e)}")
             self.statusBar().showMessage("Query execution failed")
 
+    def _update_query_history(self, query):
+        """Update query history and track term usage for improved autocompletion"""
+        import re
+        
+        # Initialize history if it doesn't exist
+        if not hasattr(self, 'query_history'):
+            self.query_history = []
+            self.completion_usage = {}
+        
+        # Add query to history (limit to 100 queries)
+        self.query_history.append(query)
+        if len(self.query_history) > 100:
+            self.query_history.pop(0)
+        
+        # Extract terms and patterns from the query to update usage frequency
+        
+        # Extract table and column names
+        table_pattern = r'\b([a-zA-Z0-9_]+)\b\.([a-zA-Z0-9_]+)\b'
+        qualified_columns = re.findall(table_pattern, query)
+        for table, column in qualified_columns:
+            qualified_name = f"{table}.{column}"
+            self.completion_usage[qualified_name] = self.completion_usage.get(qualified_name, 0) + 1
+            
+            # Also count the table and column separately
+            self.completion_usage[table] = self.completion_usage.get(table, 0) + 1
+            self.completion_usage[column] = self.completion_usage.get(column, 0) + 1
+        
+        # Extract SQL keywords
+        keyword_pattern = r'\b([A-Z_]{2,})\b'
+        keywords = re.findall(keyword_pattern, query.upper())
+        for keyword in keywords:
+            self.completion_usage[keyword] = self.completion_usage.get(keyword, 0) + 1
+        
+        # Extract common SQL patterns
+        patterns = [
+            r'(SELECT\s+.*?\s+FROM)',
+            r'(GROUP\s+BY\s+.*?(?:HAVING|ORDER|LIMIT|$))',
+            r'(ORDER\s+BY\s+.*?(?:LIMIT|$))',
+            r'(INNER\s+JOIN|LEFT\s+JOIN|RIGHT\s+JOIN|FULL\s+JOIN).*?ON\s+.*?=\s+.*?(?:WHERE|JOIN|GROUP|ORDER|LIMIT|$)',
+            r'(INSERT\s+INTO\s+.*?\s+VALUES)',
+            r'(UPDATE\s+.*?\s+SET\s+.*?\s+WHERE)',
+            r'(DELETE\s+FROM\s+.*?\s+WHERE)'
+        ]
+        
+        for pattern in patterns:
+            matches = re.findall(pattern, query, re.IGNORECASE | re.DOTALL)
+            for match in matches:
+                # Normalize pattern by removing extra whitespace and converting to uppercase
+                normalized = re.sub(r'\s+', ' ', match).strip().upper()
+                if len(normalized) < 50:  # Only track reasonably sized patterns
+                    self.completion_usage[normalized] = self.completion_usage.get(normalized, 0) + 1
+        
+        # Schedule an update of the completion model (but not too often to avoid performance issues)
+        if not hasattr(self, '_last_completer_update') or \
+           (datetime.now() - self._last_completer_update).total_seconds() > 30:
+            self._last_completer_update = datetime.now()
+            
+            # Use a timer to delay the update to avoid blocking the UI
+            update_timer = QTimer()
+            update_timer.setSingleShot(True)
+            update_timer.timeout.connect(self.update_completer)
+            update_timer.start(1000)  # Update after 1 second
+            
     def clear_query(self):
         """Clear the query editor with animation"""
+        # Get the current tab
+        current_tab = self.get_current_tab()
+        if not current_tab:
+            return
+            
         # Save current text for animation
-        current_text = self.query_edit.toPlainText()
+        current_text = current_tab.get_query_text()
         if not current_text:
             return
         
         # Clear the editor
-        self.query_edit.clear()
+        current_tab.set_query_text("")
         
         # Show success message
         self.statusBar().showMessage('Query cleared', 2000)  # Show for 2 seconds
 
     def show_table_preview(self, item):
         """Show a preview of the selected table"""
-        if item:
-            table_name = item.text().split(' (')[0]
-            try:
-                if self.current_connection_type == 'sqlite':
-                    preview_df = pd.read_sql_query(f'SELECT * FROM "{table_name}" LIMIT 5', self.conn)
-                else:
-                    preview_df = self.conn.execute(f'SELECT * FROM {table_name} LIMIT 5').fetchdf()
-                    
-                self.populate_table(preview_df)
-                self.statusBar().showMessage(f'Showing preview of table "{table_name}"')
-                
-                # Update the results title to show which table is being previewed
-                results_title = self.findChild(QLabel, "header_label", Qt.FindChildOption.FindChildrenRecursively)
-                if results_title and results_title.text() == "RESULTS":
-                    results_title.setText(f"PREVIEW: {table_name}")
+        if not item:
+            return
+            
+        # Get the current tab
+        current_tab = self.get_current_tab()
+        if not current_tab:
+            return
+            
+        table_name = item.text().split(' (')[0]
+        try:
+            # Use the database manager to get a preview of the table
+            preview_df = self.db_manager.get_table_preview(table_name)
                 
-            except Exception as e:
-                self.results_table.setRowCount(0)
-                self.results_table.setColumnCount(0)
-                self.row_count_label.setText("")
-                self.statusBar().showMessage('Error showing table preview')
-                
-                # Show error message with modern styling
-                QMessageBox.critical(
-                    self, 
-                    "Error", 
-                    f"Error showing preview: {str(e)}",
-                    QMessageBox.StandardButton.Ok
-                )
+            self.populate_table(preview_df)
+            self.statusBar().showMessage(f'Showing preview of table "{table_name}"')
+            
+            # Update the results title to show which table is being previewed
+            current_tab.results_title.setText(f"PREVIEW: {table_name}")
+            
+        except Exception as e:
+            current_tab.results_table.setRowCount(0)
+            current_tab.results_table.setColumnCount(0)
+            current_tab.row_count_label.setText("")
+            self.statusBar().showMessage('Error showing table preview')
+            
+            # Show error message with modern styling
+            QMessageBox.critical(
+                self, 
+                "Error", 
+                f"Error showing preview: {str(e)}",
+                QMessageBox.StandardButton.Ok
+            )
 
     def load_test_data(self):
         """Generate and load test data"""
         try:
             # Ensure we have a DuckDB connection
-            if not self.conn or self.current_connection_type != 'duckdb':
-                self.conn = duckdb.connect(':memory:')
-                self.current_connection_type = 'duckdb'
-                self.db_info_label.setText("Connected to: in-memory DuckDB")
+            if not self.db_manager.is_connected() or self.db_manager.connection_type != 'duckdb':
+                connection_info = self.db_manager.create_memory_connection()
+                self.db_info_label.setText(connection_info)
 
             # Show loading indicator
             self.statusBar().showMessage('Generating test data...')
@@ -1350,28 +1202,20 @@ class SQLShell(QMainWindow):
             customer_df.to_parquet('test_data/customer_data.parquet', index=False)
             product_df.to_excel('test_data/product_catalog.xlsx', index=False)
             
-            # Load the files into DuckDB
-            self.conn.register('sample_sales_data', sales_df)
-            self.conn.register('product_catalog', product_df)
-            self.conn.register('customer_data', customer_df)
-            
-            # Update loaded tables tracking
-            self.loaded_tables['sample_sales_data'] = 'test_data/sample_sales_data.xlsx'
-            self.loaded_tables['product_catalog'] = 'test_data/product_catalog.xlsx'
-            self.loaded_tables['customer_data'] = 'test_data/customer_data.parquet'
-            
-            # Store column names
-            self.table_columns['sample_sales_data'] = sales_df.columns.tolist()
-            self.table_columns['product_catalog'] = product_df.columns.tolist()
-            self.table_columns['customer_data'] = customer_df.columns.tolist()
+            # 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')
             
             # Update UI
             self.tables_list.clear()
-            for table_name, file_path in self.loaded_tables.items():
+            for table_name, file_path in self.db_manager.loaded_tables.items():
                 self.tables_list.addItem(f"{table_name} ({os.path.basename(file_path)})")
             
-            # Set the sample query
-            sample_query = """
+            # Set the sample query in the current tab
+            current_tab = self.get_current_tab()
+            if current_tab:
+                sample_query = """
 SELECT 
     DISTINCT
     c.customername     
@@ -1381,7 +1225,7 @@ FROM
     INNER JOIN product_catalog p ON p.productid = s.productid
 LIMIT 10
 """
-            self.query_edit.setPlainText(sample_query.strip())
+                current_tab.set_query_text(sample_query.strip())
             
             # Update completer
             self.update_completer()
@@ -1397,7 +1241,12 @@ LIMIT 10
             QMessageBox.critical(self, "Error", f"Failed to load test data: {str(e)}")
 
     def export_to_excel(self):
-        if self.results_table.rowCount() == 0:
+        # Get the current tab
+        current_tab = self.get_current_tab()
+        if not current_tab:
+            return
+            
+        if current_tab.results_table.rowCount() == 0:
             QMessageBox.warning(self, "No Data", "There is no data to export.")
             return
         
@@ -1415,21 +1264,21 @@ LIMIT 10
             
             # Generate table name from file name
             base_name = os.path.splitext(os.path.basename(file_name))[0]
-            table_name = self.sanitize_table_name(base_name)
+            table_name = self.db_manager.sanitize_table_name(base_name)
             
             # Ensure unique table name
             original_name = table_name
             counter = 1
-            while table_name in self.loaded_tables:
+            while table_name in self.db_manager.loaded_tables:
                 table_name = f"{original_name}_{counter}"
                 counter += 1
             
-            # Register the table in DuckDB
-            self.conn.register(table_name, df)
+            # Register the table in the database manager
+            self.db_manager.register_dataframe(df, table_name, file_name)
             
             # Update tracking
-            self.loaded_tables[table_name] = file_name
-            self.table_columns[table_name] = df.columns.tolist()
+            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)})")
@@ -1450,7 +1299,12 @@ LIMIT 10
             self.statusBar().showMessage('Error exporting data')
 
     def export_to_parquet(self):
-        if self.results_table.rowCount() == 0:
+        # Get the current tab
+        current_tab = self.get_current_tab()
+        if not current_tab:
+            return
+            
+        if current_tab.results_table.rowCount() == 0:
             QMessageBox.warning(self, "No Data", "There is no data to export.")
             return
         
@@ -1468,21 +1322,21 @@ LIMIT 10
             
             # Generate table name from file name
             base_name = os.path.splitext(os.path.basename(file_name))[0]
-            table_name = self.sanitize_table_name(base_name)
+            table_name = self.db_manager.sanitize_table_name(base_name)
             
             # Ensure unique table name
             original_name = table_name
             counter = 1
-            while table_name in self.loaded_tables:
+            while table_name in self.db_manager.loaded_tables:
                 table_name = f"{original_name}_{counter}"
                 counter += 1
             
-            # Register the table in DuckDB
-            self.conn.register(table_name, df)
+            # Register the table in the database manager
+            self.db_manager.register_dataframe(df, table_name, file_name)
             
             # Update tracking
-            self.loaded_tables[table_name] = file_name
-            self.table_columns[table_name] = df.columns.tolist()
+            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)})")
@@ -1504,12 +1358,17 @@ LIMIT 10
 
     def get_table_data_as_dataframe(self):
         """Helper function to convert table widget data to a DataFrame"""
-        headers = [self.results_table.horizontalHeaderItem(i).text() for i in range(self.results_table.columnCount())]
+        # Get the current tab
+        current_tab = self.get_current_tab()
+        if not current_tab:
+            return pd.DataFrame()
+            
+        headers = [current_tab.results_table.horizontalHeaderItem(i).text() for i in range(current_tab.results_table.columnCount())]
         data = []
-        for row in range(self.results_table.rowCount()):
+        for row in range(current_tab.results_table.rowCount()):
             row_data = []
-            for column in range(self.results_table.columnCount()):
-                item = self.results_table.item(row, column)
+            for column in range(current_tab.results_table.columnCount()):
+                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)
@@ -1518,12 +1377,27 @@ LIMIT 10
         """Handle global keyboard shortcuts"""
         # Execute query with Ctrl+Enter or Cmd+Enter (for Mac)
         if event.key() == Qt.Key.Key_Return and (event.modifiers() & Qt.KeyboardModifier.ControlModifier):
-            self.execute_btn.click()  # Simply click the button instead of animating
+            self.execute_query()
             return
         
-        # Clear query with Ctrl+L
-        if event.key() == Qt.Key.Key_L and (event.modifiers() & Qt.KeyboardModifier.ControlModifier):
-            self.clear_btn.click()  # Simply click the button instead of animating
+        # Add new tab with Ctrl+T
+        if event.key() == Qt.Key.Key_T and (event.modifiers() & Qt.KeyboardModifier.ControlModifier):
+            self.add_tab()
+            return
+            
+        # Close current tab with Ctrl+W
+        if event.key() == Qt.Key.Key_W and (event.modifiers() & Qt.KeyboardModifier.ControlModifier):
+            self.close_current_tab()
+            return
+            
+        # Duplicate tab with Ctrl+D
+        if event.key() == Qt.Key.Key_D and (event.modifiers() & Qt.KeyboardModifier.ControlModifier):
+            self.duplicate_current_tab()
+            return
+            
+        # Rename tab with Ctrl+R
+        if event.key() == Qt.Key.Key_R and (event.modifiers() & Qt.KeyboardModifier.ControlModifier):
+            self.rename_current_tab()
             return
         
         super().keyPressEvent(event)
@@ -1545,12 +1419,11 @@ LIMIT 10
                     event.ignore()
                     return
             
+            # Save window state and settings
+            self.save_recent_projects()
+            
             # Close database connections
-            if self.conn:
-                if self.current_connection_type == "duckdb":
-                    self.conn.close()
-                else:  # sqlite
-                    self.conn.close()
+            self.db_manager.close_connection()
             event.accept()
         except Exception as e:
             QMessageBox.warning(self, "Cleanup Warning", 
@@ -1560,27 +1433,54 @@ LIMIT 10
     def has_unsaved_changes(self):
         """Check if there are unsaved changes in the project"""
         if not self.current_project_file:
-            return bool(self.loaded_tables or self.query_edit.toPlainText().strip())
+            return (self.tab_widget.count() > 0 and any(self.tab_widget.widget(i).get_query_text().strip() 
+                                                        for i in range(self.tab_widget.count()))) or bool(self.db_manager.loaded_tables)
         
         try:
             # Load the last saved state
             with open(self.current_project_file, 'r') as f:
                 saved_data = json.load(f)
             
+            # Prepare current tab data
+            current_tabs_data = []
+            for i in range(self.tab_widget.count()):
+                tab = self.tab_widget.widget(i)
+                tab_data = {
+                    'title': self.tab_widget.tabText(i),
+                    'query': tab.get_query_text()
+                }
+                current_tabs_data.append(tab_data)
+            
             # Compare current state with saved state
             current_data = {
                 'tables': {
                     name: {
                         'file_path': path,
-                        'columns': self.table_columns.get(name, [])
+                        'columns': self.db_manager.table_columns.get(name, [])
                     }
-                    for name, path in self.loaded_tables.items()
+                    for name, path in self.db_manager.loaded_tables.items()
                 },
-                'query': self.query_edit.toPlainText(),
-                'connection_type': self.current_connection_type
+                'tabs': current_tabs_data,
+                'connection_type': self.db_manager.connection_type
             }
             
-            return current_data != saved_data
+            # Compare tables and connection type
+            if (current_data['connection_type'] != saved_data.get('connection_type') or
+                len(current_data['tables']) != len(saved_data.get('tables', {}))):
+                return True
+                
+            # Compare tab data
+            if 'tabs' not in saved_data or len(current_data['tabs']) != len(saved_data['tabs']):
+                return True
+                
+            for i, tab_data in enumerate(current_data['tabs']):
+                saved_tab = saved_data['tabs'][i]
+                if (tab_data['title'] != saved_tab.get('title', '') or
+                    tab_data['query'] != saved_tab.get('query', '')):
+                    return True
+            
+            # If we get here, everything matches
+            return False
             
         except Exception:
             # If there's any error reading the saved file, assume there are unsaved changes
@@ -1592,6 +1492,11 @@ LIMIT 10
         if not item:
             return
 
+        # Get current tab
+        current_tab = self.get_current_tab()
+        if not current_tab:
+            return
+
         # Get table name without the file info in parentheses
         table_name = item.text().split(' (')[0]
 
@@ -1615,45 +1520,79 @@ LIMIT 10
         # Add menu actions
         select_from_action = context_menu.addAction("Select from")
         add_to_editor_action = context_menu.addAction("Just add to editor")
+        context_menu.addSeparator()
+        rename_action = context_menu.addAction("Rename table...")
+        delete_action = context_menu.addAction("Delete table")
+        delete_action.setIcon(QIcon.fromTheme("edit-delete"))
 
         # Show menu and get selected action
         action = context_menu.exec(self.tables_list.mapToGlobal(position))
 
         if action == select_from_action:
             # Insert "SELECT * FROM table_name" at cursor position
-            cursor = self.query_edit.textCursor()
+            cursor = current_tab.query_edit.textCursor()
             cursor.insertText(f"SELECT * FROM {table_name}")
-            self.query_edit.setFocus()
+            current_tab.query_edit.setFocus()
         elif action == add_to_editor_action:
             # Just insert the table name at cursor position
-            cursor = self.query_edit.textCursor()
+            cursor = current_tab.query_edit.textCursor()
             cursor.insertText(table_name)
-            self.query_edit.setFocus()
+            current_tab.query_edit.setFocus()
+        elif action == rename_action:
+            # Show rename dialog
+            new_name, ok = QInputDialog.getText(
+                self,
+                "Rename Table",
+                "Enter new table name:",
+                QLineEdit.EchoMode.Normal,
+                table_name
+            )
+            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})")
+                    self.statusBar().showMessage(f'Table renamed to "{new_name}"')
+        elif action == delete_action:
+            # Show confirmation dialog
+            reply = QMessageBox.question(
+                self,
+                "Delete Table",
+                f"Are you sure you want to delete table '{table_name}'?",
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
+            )
+            if reply == QMessageBox.StandardButton.Yes:
+                self.remove_selected_table()
 
     def new_project(self):
         """Create a new project by clearing current state"""
-        if self.conn:
+        if self.db_manager.is_connected():
             reply = QMessageBox.question(self, 'New Project',
                                        'Are you sure you want to start a new project? All unsaved changes will be lost.',
                                        QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
             if reply == QMessageBox.StandardButton.Yes:
                 # Close existing connection
-                if self.current_connection_type == "duckdb":
-                    self.conn.close()
-                else:  # sqlite
-                    self.conn.close()
+                self.db_manager.close_connection()
                 
                 # Reset state
-                self.conn = None
-                self.current_connection_type = None
-                self.loaded_tables.clear()
-                self.table_columns.clear()
                 self.tables_list.clear()
-                self.query_edit.clear()
-                self.results_table.setRowCount(0)
-                self.results_table.setColumnCount(0)
+                
+                # 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")
                 self.statusBar().showMessage('New project created')
 
     def save_project(self):
@@ -1683,14 +1622,29 @@ LIMIT 10
     def save_project_to_file(self, file_name):
         """Save project data to a file"""
         try:
+            # Save tab information
+            tabs_data = []
+            for i in range(self.tab_widget.count()):
+                tab = self.tab_widget.widget(i)
+                tab_data = {
+                    'title': self.tab_widget.tabText(i),
+                    'query': tab.get_query_text()
+                }
+                tabs_data.append(tab_data)
+            
             project_data = {
                 'tables': {},
-                'query': self.query_edit.toPlainText(),
-                'connection_type': self.current_connection_type
+                'tabs': tabs_data,
+                'connection_type': self.db_manager.connection_type,
+                'database_path': None  # Initialize to None
             }
             
+            # If we have a database connection, save the path
+            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.loaded_tables.items():
+            for table_name, file_path in self.db_manager.loaded_tables.items():
                 # For database tables and query results, store the special identifier
                 if file_path in ['database', 'query_result']:
                     source_path = file_path
@@ -1700,103 +1654,683 @@ LIMIT 10
                 
                 project_data['tables'][table_name] = {
                     'file_path': source_path,
-                    'columns': self.table_columns.get(table_name, [])
+                    'columns': self.db_manager.table_columns.get(table_name, [])
                 }
             
             with open(file_name, 'w') as f:
                 json.dump(project_data, f, indent=4)
                 
+            # Add to recent projects
+            self.add_recent_project(os.path.abspath(file_name))
+                
             self.statusBar().showMessage(f'Project saved to {file_name}')
             
         except Exception as e:
             QMessageBox.critical(self, "Error",
                 f"Failed to save project:\n\n{str(e)}")
 
-    def open_project(self):
+    def open_project(self, file_name=None):
         """Open a project file"""
-        file_name, _ = QFileDialog.getOpenFileName(
-            self,
-            "Open Project",
-            "",
-            "SQL Shell Project (*.sqls);;All Files (*)"
-        )
+        if not file_name:
+            file_name, _ = QFileDialog.getOpenFileName(
+                self,
+                "Open Project",
+                "",
+                "SQL Shell Project (*.sqls);;All Files (*)"
+            )
         
         if file_name:
             try:
+                # Create a progress dialog to keep UI responsive
+                progress = QProgressDialog("Loading project...", "Cancel", 0, 100, self)
+                progress.setWindowTitle("Opening Project")
+                progress.setWindowModality(Qt.WindowModality.WindowModal)
+                progress.setMinimumDuration(500)  # Show after 500ms delay
+                progress.setValue(0)
+                
+                # Load project data
                 with open(file_name, 'r') as f:
                     project_data = json.load(f)
                 
+                # Update progress
+                progress.setValue(10)
+                QApplication.processEvents()
+                
                 # Start fresh
                 self.new_project()
+                progress.setValue(15)
+                QApplication.processEvents()
+                
+                # 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
+                database_tables_loaded = False
+                
+                # 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_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",
+                                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.")
+                    except Exception as e:
+                        database_tables_loaded = False
+                        QMessageBox.warning(self, "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.")
+                else:
+                    # Create connection if needed (we don't have a specific database to connect to)
+                    database_tables_loaded = False
+                    if not self.db_manager.is_connected():
+                        connection_info = self.db_manager.create_memory_connection()
+                        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",
+                            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.")
                 
-                # Create connection if needed
-                if not self.conn:
-                    self.conn = duckdb.connect(':memory:')
-                    self.current_connection_type = 'duckdb'
-                    self.db_info_label.setText("Connected to: in-memory DuckDB")
+                progress.setValue(30)
+                QApplication.processEvents()
+                
+                # Calculate progress steps for loading tables
+                table_count = len(project_data.get('tables', {}))
+                table_progress_start = 30
+                table_progress_end = 70
+                table_progress_step = (table_progress_end - table_progress_start) / max(1, table_count)
+                current_progress = table_progress_start
                 
                 # Load tables
-                for table_name, table_info in project_data['tables'].items():
+                for table_name, table_info in project_data.get('tables', {}).items():
+                    if progress.wasCanceled():
+                        break
+                        
+                    progress.setLabelText(f"Loading table: {table_name}")
                     file_path = table_info['file_path']
                     try:
                         if file_path == 'database':
-                            # For tables from database, we need to recreate them from their data
-                            # Execute a SELECT to get the data and recreate the table
-                            query = f"SELECT * FROM {table_name}"
-                            df = pd.read_sql_query(query, self.conn)
-                            self.conn.register(table_name, df)
-                            self.loaded_tables[table_name] = 'database'
+                            # Skip if we already loaded database tables by connecting to the database
+                            if database_tables_loaded:
+                                continue
+                                
+                            # 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)")
                         elif file_path == 'query_result':
                             # For tables from query results, we'll need to re-run the query
                             # For now, just note it as a query result table
-                            self.loaded_tables[table_name] = 'query_result'
+                            self.db_manager.loaded_tables[table_name] = 'query_result'
                             self.tables_list.addItem(f"{table_name} (query result)")
                         elif os.path.exists(file_path):
-                            # Load the file based on its extension
-                            if file_path.endswith(('.xlsx', '.xls')):
-                                df = pd.read_excel(file_path)
-                            elif file_path.endswith('.csv'):
-                                df = pd.read_csv(file_path)
-                            elif file_path.endswith('.parquet'):
-                                df = pd.read_parquet(file_path)
-                            else:
+                            # 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 table
-                            self.conn.register(table_name, df)
-                            self.loaded_tables[table_name] = file_path
-                            self.tables_list.addItem(f"{table_name} ({os.path.basename(file_path)})")
                         else:
                             QMessageBox.warning(self, "Warning",
                                 f"Could not find file for table {table_name}: {file_path}")
                             continue
                             
-                        # Store the columns
-                        self.table_columns[table_name] = table_info['columns']
-                            
                     except Exception as e:
                         QMessageBox.warning(self, "Warning",
                             f"Failed to load table {table_name}:\n{str(e)}")
                 
-                # Restore query
-                if 'query' in project_data:
-                    self.query_edit.setPlainText(project_data['query'])
+                    # Update 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")
+                    progress.close()
+                    return
+                
+                progress.setValue(75)
+                progress.setLabelText("Setting up tabs...")
+                QApplication.processEvents()
+                
+                # Load tabs in a more efficient way
+                if 'tabs' in project_data and project_data['tabs']:
+                    try:
+                        # Temporarily disable signals
+                        self.tab_widget.blockSignals(True)
+                        
+                        # First, pre-remove any existing tabs
+                        while self.tab_widget.count() > 0:
+                            widget = self.tab_widget.widget(0)
+                            self.tab_widget.removeTab(0)
+                            if widget in self.tabs:
+                                self.tabs.remove(widget)
+                            widget.deleteLater()
+                        
+                        # Then create all tab widgets at once (empty)
+                        tab_count = len(project_data['tabs'])
+                        tab_progress_step = 15 / max(1, tab_count)
+                        progress.setValue(80)
+                        QApplication.processEvents()
+                        
+                        # Create all tab widgets first without setting content
+                        for i, tab_data in enumerate(project_data['tabs']):
+                            # Create a new tab
+                            tab = QueryTab(self)
+                            self.tabs.append(tab)
+                            
+                            # Add to tab widget
+                            title = tab_data.get('title', f'Query {i+1}')
+                            self.tab_widget.addTab(tab, title)
+                            
+                            progress.setValue(int(80 + i * tab_progress_step/2))
+                            QApplication.processEvents()
+                        
+                        # Now set the content for each tab
+                        for i, tab_data in enumerate(project_data['tabs']):
+                            # Get the tab and set its query text
+                            tab = self.tab_widget.widget(i)
+                            if tab and 'query' in tab_data:
+                                tab.set_query_text(tab_data['query'])
+                            
+                            progress.setValue(int(87 + i * tab_progress_step/2))
+                            QApplication.processEvents()
+                        
+                        # Re-enable signals
+                        self.tab_widget.blockSignals(False)
+                        
+                        # Set current tab
+                        if self.tab_widget.count() > 0:
+                            self.tab_widget.setCurrentIndex(0)
+                            
+                    except Exception as e:
+                        # If there's an error, ensure we restore signals
+                        self.tab_widget.blockSignals(False)
+                        self.statusBar().showMessage(f"Error loading tabs: {str(e)}")
+                        # Create a single default tab if all fails
+                        if self.tab_widget.count() == 0:
+                            self.add_tab()
+                else:
+                    # Create default tab if no tabs in project
+                    self.add_tab()
+                
+                progress.setValue(90)
+                progress.setLabelText("Finishing up...")
+                QApplication.processEvents()
                 
                 # Update UI
                 self.current_project_file = file_name
                 self.setWindowTitle(f'SQL Shell - {os.path.basename(file_name)}')
+                
+                # Add to recent projects
+                self.add_recent_project(os.path.abspath(file_name))
+                
+                # Defer the auto-completer update to after loading is complete
+                # This helps prevent UI freezing during project loading
+                progress.setValue(95)
+                QApplication.processEvents()
+                
+                # Use a timer to update the completer after the UI is responsive
+                complete_timer = QTimer()
+                complete_timer.setSingleShot(True)
+                complete_timer.timeout.connect(self.update_completer)
+                complete_timer.start(100)  # Short delay before updating completer
+                
+                # Queue another update for reliability - sometimes the first update might not fully complete
+                failsafe_timer = QTimer()
+                failsafe_timer.setSingleShot(True)
+                failsafe_timer.timeout.connect(self.update_completer)
+                failsafe_timer.start(2000)  # Try again after 2 seconds to ensure completion is loaded
+                
+                progress.setValue(100)
+                QApplication.processEvents()
+                
                 self.statusBar().showMessage(f'Project loaded from {file_name}')
-                self.update_completer()
+                progress.close()
                 
             except Exception as e:
                 QMessageBox.critical(self, "Error",
                     f"Failed to open project:\n\n{str(e)}")
 
+    def rename_table(self, old_name, new_name):
+        """Rename a table in the database and update tracking"""
+        try:
+            # Use the database manager to rename the table
+            result = self.db_manager.rename_table(old_name, new_name)
+            
+            if result:
+                # Update completer
+                self.update_completer()
+                return True
+            
+            return False
+            
+        except Exception as e:
+            QMessageBox.critical(self, "Error", f"Failed to rename table:\n\n{str(e)}")
+            return False
+
+    def load_recent_projects(self):
+        """Load recent projects 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_projects = settings.get('recent_projects', [])
+                    
+                    # Load window settings if available
+                    window_settings = settings.get('window', {})
+                    if window_settings:
+                        self.restore_window_state(window_settings)
+        except Exception:
+            self.recent_projects = []
+
+    def save_recent_projects(self):
+        """Save recent projects 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_projects'] = self.recent_projects
+            
+            # Save window settings
+            window_settings = self.save_window_state()
+            settings['window'] = window_settings
+            
+            with open(settings_file, 'w') as f:
+                json.dump(settings, f, indent=4)
+        except Exception as e:
+            print(f"Error saving recent projects: {e}")
+            
+    def save_window_state(self):
+        """Save current window state"""
+        window_settings = {
+            'maximized': self.isMaximized(),
+            'geometry': {
+                'x': self.geometry().x(),
+                'y': self.geometry().y(),
+                'width': self.geometry().width(),
+                'height': self.geometry().height()
+            }
+        }
+        return window_settings
+        
+    def restore_window_state(self, window_settings):
+        """Restore window state from settings"""
+        try:
+            # Check if we have valid geometry settings
+            geometry = window_settings.get('geometry', {})
+            if all(key in geometry for key in ['x', 'y', 'width', 'height']):
+                x, y = geometry['x'], geometry['y']
+                width, height = geometry['width'], geometry['height']
+                
+                # Ensure the window is visible on the current screen
+                screen = QApplication.primaryScreen()
+                screen_geometry = screen.availableGeometry()
+                
+                # Adjust if window would be off-screen
+                if x < 0 or x + 100 > screen_geometry.width():
+                    x = 100
+                if y < 0 or y + 100 > screen_geometry.height():
+                    y = 100
+                    
+                # Adjust if window is too large for the current screen
+                if width > screen_geometry.width():
+                    width = int(screen_geometry.width() * 0.85)
+                if height > screen_geometry.height():
+                    height = int(screen_geometry.height() * 0.85)
+                
+                self.setGeometry(x, y, width, height)
+            
+            # Set maximized state if needed
+            if window_settings.get('maximized', False):
+                self.showMaximized()
+                self.was_maximized = True
+                
+        except Exception as e:
+            print(f"Error restoring window state: {e}")
+            # Fall back to default geometry
+            screen = QApplication.primaryScreen()
+            screen_geometry = screen.availableGeometry()
+            self.setGeometry(100, 100, 
+                            min(1400, int(screen_geometry.width() * 0.85)), 
+                            min(800, int(screen_geometry.height() * 0.85)))
+
+    def add_recent_project(self, project_path):
+        """Add a project to recent projects list"""
+        if project_path in self.recent_projects:
+            self.recent_projects.remove(project_path)
+        self.recent_projects.insert(0, project_path)
+        self.recent_projects = self.recent_projects[:self.max_recent_projects]
+        self.save_recent_projects()
+        self.update_recent_projects_menu()
+
+    def update_recent_projects_menu(self):
+        """Update the recent projects menu"""
+        self.recent_projects_menu.clear()
+        
+        if not self.recent_projects:
+            no_recent = self.recent_projects_menu.addAction("No Recent Projects")
+            no_recent.setEnabled(False)
+            return
+            
+        for project_path in self.recent_projects:
+            if os.path.exists(project_path):
+                action = self.recent_projects_menu.addAction(os.path.basename(project_path))
+                action.setData(project_path)
+                action.triggered.connect(lambda checked, path=project_path: self.open_recent_project(path))
+        
+        if self.recent_projects:
+            self.recent_projects_menu.addSeparator()
+            clear_action = self.recent_projects_menu.addAction("Clear Recent Projects")
+            clear_action.triggered.connect(self.clear_recent_projects)
+
+    def open_recent_project(self, project_path):
+        """Open a project from the recent projects list"""
+        if os.path.exists(project_path):
+            self.current_project_file = project_path
+            self.open_project(project_path)
+        else:
+            QMessageBox.warning(self, "Warning",
+                f"Project file not found:\n{project_path}")
+            self.recent_projects.remove(project_path)
+            self.save_recent_projects()
+            self.update_recent_projects_menu()
+
+    def clear_recent_projects(self):
+        """Clear the list of recent projects"""
+        self.recent_projects.clear()
+        self.save_recent_projects()
+        self.update_recent_projects_menu()
+
+    def add_tab(self, title="Query 1"):
+        """Add a new query tab"""
+        # Ensure title is a string
+        title = str(title)
+        
+        # Create a new tab with a unique name if needed
+        if title == "Query 1" and self.tab_widget.count() > 0:
+            # Generate a unique tab name (Query 2, Query 3, etc.)
+            # Use a more efficient approach to find a unique name
+            base_name = "Query"
+            existing_names = set()
+            
+            # Collect existing tab names first (more efficient than checking each time)
+            for i in range(self.tab_widget.count()):
+                existing_names.add(self.tab_widget.tabText(i))
+            
+            # Find the next available number
+            counter = 1
+            while f"{base_name} {counter}" in existing_names:
+                counter += 1
+            title = f"{base_name} {counter}"
+        
+        # Create the tab content
+        tab = QueryTab(self)
+        
+        # Add to our list of tabs
+        self.tabs.append(tab)
+        
+        # Block signals temporarily to improve performance when adding many tabs
+        was_blocked = self.tab_widget.blockSignals(True)
+        
+        # Add tab to widget
+        index = self.tab_widget.addTab(tab, title)
+        self.tab_widget.setCurrentIndex(index)
+        
+        # Restore signals
+        self.tab_widget.blockSignals(was_blocked)
+        
+        # Focus the new tab's query editor
+        tab.query_edit.setFocus()
+        
+        # Process events to keep UI responsive
+        QApplication.processEvents()
+        
+        return tab
+    
+    def duplicate_current_tab(self):
+        """Duplicate the current tab"""
+        if self.tab_widget.count() == 0:
+            return self.add_tab()
+            
+        current_idx = self.tab_widget.currentIndex()
+        if current_idx == -1:
+            return
+            
+        # Get current tab data
+        current_tab = self.get_current_tab()
+        current_title = self.tab_widget.tabText(current_idx)
+        
+        # Create a new tab with "(Copy)" suffix
+        new_title = f"{current_title} (Copy)"
+        new_tab = self.add_tab(new_title)
+        
+        # Copy query text
+        new_tab.set_query_text(current_tab.get_query_text())
+        
+        # Return focus to the new tab
+        new_tab.query_edit.setFocus()
+        
+        return new_tab
+    
+    def rename_current_tab(self):
+        """Rename the current tab"""
+        current_idx = self.tab_widget.currentIndex()
+        if current_idx == -1:
+            return
+            
+        current_title = self.tab_widget.tabText(current_idx)
+        
+        new_title, ok = QInputDialog.getText(
+            self,
+            "Rename Tab",
+            "Enter new tab name:",
+            QLineEdit.EchoMode.Normal,
+            current_title
+        )
+        
+        if ok and new_title:
+            self.tab_widget.setTabText(current_idx, new_title)
+    
+    def handle_tab_double_click(self, index):
+        """Handle double-clicking on a tab by starting rename immediately"""
+        if index == -1:
+            return
+            
+        current_title = self.tab_widget.tabText(index)
+        
+        new_title, ok = QInputDialog.getText(
+            self,
+            "Rename Tab",
+            "Enter new tab name:",
+            QLineEdit.EchoMode.Normal,
+            current_title
+        )
+        
+        if ok and new_title:
+            self.tab_widget.setTabText(index, new_title)
+    
+    def close_tab(self, index):
+        """Close the tab at the given index"""
+        if self.tab_widget.count() <= 1:
+            # Don't close the last tab, just clear it
+            tab = self.get_tab_at_index(index)
+            if tab:
+                tab.set_query_text("")
+                tab.results_table.clearContents()
+                tab.results_table.setRowCount(0)
+                tab.results_table.setColumnCount(0)
+            return
+            
+        # 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
+        self.tab_widget.blockSignals(was_blocked)
+        
+        # Remove from our list of tabs
+        if widget in self.tabs:
+            self.tabs.remove(widget)
+        
+        # Schedule the widget for deletion instead of immediate deletion
+        widget.deleteLater()
+        
+        # Process events to keep UI responsive
+        QApplication.processEvents()
+    
+    def close_current_tab(self):
+        """Close the current tab"""
+        current_idx = self.tab_widget.currentIndex()
+        if current_idx != -1:
+            self.close_tab(current_idx)
+    
+    def get_current_tab(self):
+        """Get the currently active tab"""
+        current_idx = self.tab_widget.currentIndex()
+        if current_idx == -1:
+            return None
+        return self.tab_widget.widget(current_idx)
+        
+    def get_tab_at_index(self, index):
+        """Get the tab at the specified index"""
+        if index < 0 or index >= self.tab_widget.count():
+            return None
+        return self.tab_widget.widget(index)
+
+    def toggle_maximize_window(self):
+        """Toggle between maximized and normal window state"""
+        if self.isMaximized():
+            self.showNormal()
+            self.was_maximized = False
+        else:
+            self.showMaximized()
+            self.was_maximized = True
+            
+    def change_zoom(self, factor):
+        """Change the zoom level of the application by adjusting font sizes"""
+        try:
+            # Update font sizes for SQL editors
+            for i in range(self.tab_widget.count()):
+                tab = self.tab_widget.widget(i)
+                if hasattr(tab, 'query_edit'):
+                    # Get current font
+                    current_font = tab.query_edit.font()
+                    current_size = current_font.pointSizeF()
+                    
+                    # Calculate new size with limits to prevent too small/large fonts
+                    new_size = current_size * factor
+                    if 6 <= new_size <= 72:  # Reasonable limits
+                        current_font.setPointSizeF(new_size)
+                        tab.query_edit.setFont(current_font)
+                        
+                    # Also update the line number area
+                    tab.query_edit.update_line_number_area_width(0)
+                
+                # Update results table font if needed
+                if hasattr(tab, 'results_table'):
+                    table_font = tab.results_table.font()
+                    table_size = table_font.pointSizeF()
+                    new_table_size = table_size * factor
+                    
+                    if 6 <= new_table_size <= 72:
+                        table_font.setPointSizeF(new_table_size)
+                        tab.results_table.setFont(table_font)
+                        # Resize rows and columns to fit new font size
+                        tab.results_table.resizeColumnsToContents()
+                        tab.results_table.resizeRowsToContents()
+            
+            # Update status bar
+            self.statusBar().showMessage(f"Zoom level adjusted to {int(current_size * factor)}", 2000)
+            
+        except Exception as e:
+            self.statusBar().showMessage(f"Error adjusting zoom: {str(e)}", 2000)
+            
+    def reset_zoom(self):
+        """Reset zoom level to default"""
+        try:
+            # Default font sizes
+            sql_editor_size = 12
+            table_size = 10
+            
+            # Update all tabs
+            for i in range(self.tab_widget.count()):
+                tab = self.tab_widget.widget(i)
+                
+                # Reset editor font
+                if hasattr(tab, 'query_edit'):
+                    editor_font = tab.query_edit.font()
+                    editor_font.setPointSizeF(sql_editor_size)
+                    tab.query_edit.setFont(editor_font)
+                    tab.query_edit.update_line_number_area_width(0)
+                
+                # Reset table font
+                if hasattr(tab, 'results_table'):
+                    table_font = tab.results_table.font()
+                    table_font.setPointSizeF(table_size)
+                    tab.results_table.setFont(table_font)
+                    tab.results_table.resizeColumnsToContents()
+                    tab.results_table.resizeRowsToContents()
+            
+            self.statusBar().showMessage("Zoom level reset to default", 2000)
+            
+        except Exception as e:
+            self.statusBar().showMessage(f"Error resetting zoom: {str(e)}", 2000)
+
 def main():
     app = QApplication(sys.argv)
     app.setStyle(QStyleFactory.create('Fusion'))
     
+    # Set application icon
+    icon_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "resources", "icon.png")
+    if os.path.exists(icon_path):
+        app.setWindowIcon(QIcon(icon_path))
+    else:
+        # Fallback to the main logo if the icon isn't found
+        main_logo_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "sqlshell_logo.png")
+        if os.path.exists(main_logo_path):
+            app.setWindowIcon(QIcon(main_logo_path))
+    
     # Ensure we have a valid working directory with pool.db
     package_dir = os.path.dirname(os.path.abspath(__file__))
     working_dir = os.getcwd()
@@ -1812,22 +2346,71 @@ def main():
             if os.path.exists(package_db):
                 shutil.copy2(package_db, working_dir)
     
-    # Show splash screen
-    splash = AnimatedSplashScreen()
-    splash.show()
-    
-    # Create and show main window after delay
-    timer = QTimer()
-    window = SQLShell()
-    timer.timeout.connect(lambda: show_main_window())
-    timer.start(2000)  # 2 second delay
-    
-    def show_main_window():
+    try:
+        # Show splash screen
+        splash = AnimatedSplashScreen()
+        splash.show()
+        
+        # Process events immediately to ensure the splash screen appears
+        app.processEvents()
+        
+        # Create main window but don't show it yet
+        print("Initializing main application...")
+        window = SQLShell()
+        
+        # Define the function to show main window and hide splash
+        def show_main_window():
+            # Properly finish the splash screen
+            if splash:
+                splash.finish(window)
+            
+            # Show the main window
+            window.show()
+            timer.stop()
+            
+            # Also stop the failsafe timer if it's still running
+            if failsafe_timer.isActive():
+                failsafe_timer.stop()
+                
+            print("Main application started")
+        
+        # Create a failsafe timer in case the splash screen fails to show
+        def failsafe_show_window():
+            if not window.isVisible():
+                print("Failsafe timer activated - showing main window")
+                if splash:
+                    try:
+                        # First try to use the proper finish method
+                        splash.finish(window)
+                    except Exception as e:
+                        print(f"Error in failsafe finish: {e}")
+                        try:
+                            # Fall back to direct close if finish fails
+                            splash.close()
+                        except Exception:
+                            pass
+                window.show()
+        
+        # Create and show main window after delay
+        timer = QTimer()
+        timer.setSingleShot(True)  # Ensure it only fires once
+        timer.timeout.connect(show_main_window)
+        timer.start(2000)  # 2 second delay
+        
+        # Failsafe timer - show the main window after 5 seconds even if splash screen fails
+        failsafe_timer = QTimer()
+        failsafe_timer.setSingleShot(True)
+        failsafe_timer.timeout.connect(failsafe_show_window)
+        failsafe_timer.start(5000)  # 5 second delay
+        
+        sys.exit(app.exec())
+        
+    except Exception as e:
+        print(f"Error during startup: {e}")
+        # If there's any error with the splash screen, just show the main window directly
+        window = SQLShell()
         window.show()
-        splash.finish(window)
-        timer.stop()
-    
-    sys.exit(app.exec())
+        sys.exit(app.exec())
 
 if __name__ == '__main__':
     main()