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

sqlshell/main.py

@@ -1,500 +1,152 @@
 import sys
 import os
-import duckdb
-import sqlite3
+import json
+
+# Ensure proper path setup for resources when running directly
+if __name__ == "__main__":
+    project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    sys.path.insert(0, project_root)
+
 import pandas as pd
 from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout,
                            QHBoxLayout, QTextEdit, QPushButton, QFileDialog,
                            QLabel, QSplitter, QListWidget, QTableWidget,
                            QTableWidgetItem, QHeaderView, QMessageBox, QPlainTextEdit,
                            QCompleter, QFrame, QToolButton, QSizePolicy, QTabWidget,
-                           QStyleFactory, QToolBar, QStatusBar)
-from PyQt6.QtCore import Qt, QAbstractTableModel, QRegularExpression, QRect, QSize, QStringListModel, QPropertyAnimation, QEasingCurve
-from PyQt6.QtGui import QFont, QColor, QSyntaxHighlighter, QTextCharFormat, QPainter, QTextFormat, QTextCursor, QIcon, QPalette, QLinearGradient, QBrush, QPixmap
+                           QStyleFactory, QToolBar, QStatusBar, QLineEdit, QMenu,
+                           QCheckBox, QWidgetAction, QMenuBar, QInputDialog, 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
-from sqlshell.sqlshell import create_test_data  # Import from the correct location
-
-class SQLSyntaxHighlighter(QSyntaxHighlighter):
-    def __init__(self, document):
-        super().__init__(document)
-        self.highlighting_rules = []
-
-        # SQL Keywords
-        keyword_format = QTextCharFormat()
-        keyword_format.setForeground(QColor("#0000FF"))  # Blue
-        keyword_format.setFontWeight(QFont.Weight.Bold)
-        keywords = [
-            "\\bSELECT\\b", "\\bFROM\\b", "\\bWHERE\\b", "\\bAND\\b", "\\bOR\\b",
-            "\\bINNER\\b", "\\bOUTER\\b", "\\bLEFT\\b", "\\bRIGHT\\b", "\\bJOIN\\b",
-            "\\bON\\b", "\\bGROUP\\b", "\\bBY\\b", "\\bHAVING\\b", "\\bORDER\\b",
-            "\\bLIMIT\\b", "\\bOFFSET\\b", "\\bUNION\\b", "\\bEXCEPT\\b", "\\bINTERSECT\\b",
-            "\\bCREATE\\b", "\\bTABLE\\b", "\\bINDEX\\b", "\\bVIEW\\b", "\\bINSERT\\b",
-            "\\bINTO\\b", "\\bVALUES\\b", "\\bUPDATE\\b", "\\bSET\\b", "\\bDELETE\\b",
-            "\\bTRUNCATE\\b", "\\bALTER\\b", "\\bADD\\b", "\\bDROP\\b", "\\bCOLUMN\\b",
-            "\\bCONSTRAINT\\b", "\\bPRIMARY\\b", "\\bKEY\\b", "\\bFOREIGN\\b", "\\bREFERENCES\\b",
-            "\\bUNIQUE\\b", "\\bNOT\\b", "\\bNULL\\b", "\\bIS\\b", "\\bDISTINCT\\b",
-            "\\bCASE\\b", "\\bWHEN\\b", "\\bTHEN\\b", "\\bELSE\\b", "\\bEND\\b",
-            "\\bAS\\b", "\\bWITH\\b", "\\bBETWEEN\\b", "\\bLIKE\\b", "\\bIN\\b",
-            "\\bEXISTS\\b", "\\bALL\\b", "\\bANY\\b", "\\bSOME\\b", "\\bDESC\\b", "\\bASC\\b"
-        ]
-        for pattern in keywords:
-            regex = QRegularExpression(pattern, QRegularExpression.PatternOption.CaseInsensitiveOption)
-            self.highlighting_rules.append((regex, keyword_format))
-
-        # Functions
-        function_format = QTextCharFormat()
-        function_format.setForeground(QColor("#AA00AA"))  # Purple
-        functions = [
-            "\\bAVG\\b", "\\bCOUNT\\b", "\\bSUM\\b", "\\bMAX\\b", "\\bMIN\\b",
-            "\\bCOALESCE\\b", "\\bNVL\\b", "\\bNULLIF\\b", "\\bCAST\\b", "\\bCONVERT\\b",
-            "\\bLOWER\\b", "\\bUPPER\\b", "\\bTRIM\\b", "\\bLTRIM\\b", "\\bRTRIM\\b",
-            "\\bLENGTH\\b", "\\bSUBSTRING\\b", "\\bREPLACE\\b", "\\bCONCAT\\b",
-            "\\bROUND\\b", "\\bFLOOR\\b", "\\bCEIL\\b", "\\bABS\\b", "\\bMOD\\b",
-            "\\bCURRENT_DATE\\b", "\\bCURRENT_TIME\\b", "\\bCURRENT_TIMESTAMP\\b",
-            "\\bEXTRACT\\b", "\\bDATE_PART\\b", "\\bTO_CHAR\\b", "\\bTO_DATE\\b"
-        ]
-        for pattern in functions:
-            regex = QRegularExpression(pattern, QRegularExpression.PatternOption.CaseInsensitiveOption)
-            self.highlighting_rules.append((regex, function_format))
-
-        # Numbers
-        number_format = QTextCharFormat()
-        number_format.setForeground(QColor("#009900"))  # Green
-        self.highlighting_rules.append((
-            QRegularExpression("\\b[0-9]+\\b"),
-            number_format
-        ))
-
-        # Single-line string literals
-        string_format = QTextCharFormat()
-        string_format.setForeground(QColor("#CC6600"))  # Orange/Brown
-        self.highlighting_rules.append((
-            QRegularExpression("'[^']*'"),
-            string_format
-        ))
-        self.highlighting_rules.append((
-            QRegularExpression("\"[^\"]*\""),
-            string_format
-        ))
-
-        # Comments
-        comment_format = QTextCharFormat()
-        comment_format.setForeground(QColor("#777777"))  # Gray
-        comment_format.setFontItalic(True)
-        self.highlighting_rules.append((
-            QRegularExpression("--[^\n]*"),
-            comment_format
-        ))
-        
-        # Multi-line comments
-        self.comment_start_expression = QRegularExpression("/\\*")
-        self.comment_end_expression = QRegularExpression("\\*/")
-        self.multi_line_comment_format = comment_format
-
-    def highlightBlock(self, text):
-        # Apply regular expression highlighting rules
-        for pattern, format in self.highlighting_rules:
-            match_iterator = pattern.globalMatch(text)
-            while match_iterator.hasNext():
-                match = match_iterator.next()
-                self.setFormat(match.capturedStart(), match.capturedLength(), format)
-
-        # Handle multi-line comments
-        self.setCurrentBlockState(0)
-        
-        # If previous block was inside a comment, check if this block continues it
-        start_index = 0
-        if self.previousBlockState() != 1:
-            # Find the start of a comment
-            start_match = self.comment_start_expression.match(text)
-            if start_match.hasMatch():
-                start_index = start_match.capturedStart()
-            else:
-                return
-            
-        while start_index >= 0:
-            # Find the end of the comment
-            end_match = self.comment_end_expression.match(text, start_index)
-            
-            # If end match found
-            if end_match.hasMatch():
-                end_index = end_match.capturedStart()
-                comment_length = end_index - start_index + end_match.capturedLength()
-                self.setFormat(start_index, comment_length, self.multi_line_comment_format)
-                
-                # Look for next comment
-                start_match = self.comment_start_expression.match(text, start_index + comment_length)
-                if start_match.hasMatch():
-                    start_index = start_match.capturedStart()
-                else:
-                    start_index = -1
-            else:
-                # No end found, comment continues to next block
-                self.setCurrentBlockState(1)  # Still inside comment
-                comment_length = len(text) - start_index
-                self.setFormat(start_index, comment_length, self.multi_line_comment_format)
-                start_index = -1
-
-class LineNumberArea(QWidget):
-    def __init__(self, editor):
-        super().__init__(editor)
-        self.editor = editor
 
-    def sizeHint(self):
-        return QSize(self.editor.line_number_area_width(), 0)
+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
 
-    def paintEvent(self, event):
-        self.editor.line_number_area_paint_event(event)
-
-class SQLEditor(QPlainTextEdit):
+class DraggableTablesList(QListWidget):
+    """Custom QListWidget that provides better drag functionality for table names."""
+    
     def __init__(self, parent=None):
         super().__init__(parent)
-        self.line_number_area = LineNumberArea(self)
-        
-        # Set monospaced font
-        font = QFont("Consolas", 12)  # Increased font size for better readability
-        font.setFixedPitch(True)
-        self.setFont(font)
-        
-        # Connect signals
-        self.blockCountChanged.connect(self.update_line_number_area_width)
-        self.updateRequest.connect(self.update_line_number_area)
-        
-        # Initialize
-        self.update_line_number_area_width(0)
-        
-        # Set tab width to 4 spaces
-        self.setTabStopDistance(4 * self.fontMetrics().horizontalAdvance(' '))
-        
-        # Set placeholder text
-        self.setPlaceholderText("Enter your SQL query here...")
-        
-        # Initialize completer
-        self.completer = None
-        
-        # SQL Keywords for autocomplete
-        self.sql_keywords = [
-            "SELECT", "FROM", "WHERE", "AND", "OR", "INNER", "OUTER", "LEFT", "RIGHT", "JOIN",
-            "ON", "GROUP", "BY", "HAVING", "ORDER", "LIMIT", "OFFSET", "UNION", "EXCEPT", "INTERSECT",
-            "CREATE", "TABLE", "INDEX", "VIEW", "INSERT", "INTO", "VALUES", "UPDATE", "SET", "DELETE",
-            "TRUNCATE", "ALTER", "ADD", "DROP", "COLUMN", "CONSTRAINT", "PRIMARY", "KEY", "FOREIGN", "REFERENCES",
-            "UNIQUE", "NOT", "NULL", "IS", "DISTINCT", "CASE", "WHEN", "THEN", "ELSE", "END",
-            "AS", "WITH", "BETWEEN", "LIKE", "IN", "EXISTS", "ALL", "ANY", "SOME", "DESC", "ASC",
-            "AVG", "COUNT", "SUM", "MAX", "MIN", "COALESCE", "CAST", "CONVERT"
-        ]
-        
-        # Initialize with SQL keywords
-        self.set_completer(QCompleter(self.sql_keywords))
-        
-        # Set modern selection color
-        self.selection_color = QColor("#3498DB")
-        self.selection_color.setAlpha(50)  # Make it semi-transparent
-
-    def set_completer(self, completer):
-        """Set the completer for the editor"""
-        if self.completer:
-            self.completer.disconnect(self)
-            
-        self.completer = completer
-        
-        if not self.completer:
-            return
-            
-        self.completer.setWidget(self)
-        self.completer.setCompletionMode(QCompleter.CompletionMode.PopupCompletion)
-        self.completer.setCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
-        self.completer.activated.connect(self.insert_completion)
-        
-    def update_completer_model(self, words):
-        """Update the completer model with new words"""
-        if not self.completer:
-            return
-            
-        # Combine SQL keywords with table/column names
-        all_words = self.sql_keywords + words
-        
-        # Create a model with all words
-        model = QStringListModel()
-        model.setStringList(all_words)
-        
-        # Set the model to the completer
-        self.completer.setModel(model)
-        
-    def text_under_cursor(self):
-        """Get the text under the cursor for completion"""
-        tc = self.textCursor()
-        tc.select(QTextCursor.SelectionType.WordUnderCursor)
-        return tc.selectedText()
-        
-    def insert_completion(self, completion):
-        """Insert the completion text"""
-        if self.completer.widget() != self:
-            return
-            
-        tc = self.textCursor()
-        extra = len(completion) - len(self.completer.completionPrefix())
-        tc.movePosition(QTextCursor.MoveOperation.Left)
-        tc.movePosition(QTextCursor.MoveOperation.EndOfWord)
-        tc.insertText(completion[-extra:] + " ")
-        self.setTextCursor(tc)
-        
-    def complete(self):
-        """Show completion popup"""
-        prefix = self.text_under_cursor()
+        self.parent = parent
+        self.setDragEnabled(True)
+        self.setDragDropMode(QListWidget.DragDropMode.DragOnly)
         
-        if not prefix or len(prefix) < 2:  # Only show completions for words with at least 2 characters
-            if self.completer.popup().isVisible():
-                self.completer.popup().hide()
-            return
-            
-        self.completer.setCompletionPrefix(prefix)
-        
-        # If no completions, hide popup
-        if self.completer.completionCount() == 0:
-            self.completer.popup().hide()
-            return
-            
-        # Get popup and position it under the current text
-        popup = self.completer.popup()
-        popup.setCurrentIndex(self.completer.completionModel().index(0, 0))
-        
-        # Calculate position for the popup
-        cr = self.cursorRect()
-        cr.setWidth(self.completer.popup().sizeHintForColumn(0) + 
-                   self.completer.popup().verticalScrollBar().sizeHint().width())
-        
-        # Show the popup
-        self.completer.complete(cr)
-
-    def keyPressEvent(self, event):
-        # Handle completer popup navigation
-        if self.completer and self.completer.popup().isVisible():
-            # Handle navigation keys for the popup
-            if event.key() in [Qt.Key.Key_Enter, Qt.Key.Key_Return, Qt.Key.Key_Tab, 
-                              Qt.Key.Key_Escape, Qt.Key.Key_Up, Qt.Key.Key_Down]:
-                event.ignore()
-                return
+        # Apply custom styling
+        self.setStyleSheet("""
+            QListWidget {
+                background-color: rgba(255, 255, 255, 0.1);
+                border: none;
+                border-radius: 4px;
+                color: white;
+            }
+            QListWidget::item:selected {
+                background-color: rgba(255, 255, 255, 0.2);
+            }
+            QListWidget::item:hover:!selected {
+                background-color: rgba(255, 255, 255, 0.1);
+            }
+        """)
         
-        # Handle special key combinations
-        if event.key() == Qt.Key.Key_Tab:
-            # Insert 4 spaces instead of a tab character
-            self.insertPlainText("    ")
-            return
-            
-        # Auto-indentation for new lines
-        if event.key() in [Qt.Key.Key_Return, Qt.Key.Key_Enter]:
-            cursor = self.textCursor()
-            block = cursor.block()
-            text = block.text()
-            
-            # Get the indentation of the current line
-            indentation = ""
-            for char in text:
-                if char.isspace():
-                    indentation += char
-                else:
-                    break
-            
-            # Check if line ends with an opening bracket or keywords that should increase indentation
-            increase_indent = ""
-            if text.strip().endswith("(") or any(text.strip().upper().endswith(keyword) for keyword in 
-                                               ["SELECT", "FROM", "WHERE", "GROUP BY", "ORDER BY", "HAVING"]):
-                increase_indent = "    "
-                
-            # Insert new line with proper indentation
-            super().keyPressEvent(event)
-            self.insertPlainText(indentation + increase_indent)
+    def startDrag(self, supportedActions):
+        """Override startDrag to customize the drag data."""
+        item = self.currentItem()
+        if not item:
             return
             
-        # Handle keyboard shortcuts
-        if event.modifiers() == Qt.KeyboardModifier.ControlModifier:
-            if event.key() == Qt.Key.Key_Space:
-                # Show completion popup
-                self.complete()
-                return
-            elif event.key() == Qt.Key.Key_K:
-                # Comment/uncomment the selected lines
-                self.toggle_comment()
-                return
-                
-        # For normal key presses
-        super().keyPressEvent(event)
-        
-        # Check for autocomplete after typing
-        if event.text() and not event.text().isspace():
-            self.complete()
-
-    def paintEvent(self, event):
-        # Call the parent's paintEvent first
-        super().paintEvent(event)
-        
-        # Get the current cursor
-        cursor = self.textCursor()
-        
-        # If there's a selection, paint custom highlight
-        if cursor.hasSelection():
-            # Create a painter for this widget
-            painter = QPainter(self.viewport())
-            
-            # Get the selection start and end positions
-            start = cursor.selectionStart()
-            end = cursor.selectionEnd()
-            
-            # Create temporary cursor to get the rectangles
-            temp_cursor = QTextCursor(cursor)
-            
-            # Move to start and get the starting position
-            temp_cursor.setPosition(start)
-            start_pos = self.cursorRect(temp_cursor)
-            
-            # Move to end and get the ending position
-            temp_cursor.setPosition(end)
-            end_pos = self.cursorRect(temp_cursor)
-            
-            # Set the highlight color with transparency
-            painter.setBrush(QBrush(self.selection_color))
-            painter.setPen(Qt.PenStyle.NoPen)
-            
-            # Draw the highlight rectangle
-            if start_pos.top() == end_pos.top():
-                # Single line selection
-                painter.drawRect(QRect(start_pos.left(), start_pos.top(),
-                                     end_pos.right() - start_pos.left(), start_pos.height()))
-            else:
-                # Multi-line selection
-                # First line
-                painter.drawRect(QRect(start_pos.left(), start_pos.top(),
-                                     self.viewport().width() - start_pos.left(), start_pos.height()))
-                
-                # Middle lines (if any)
-                if end_pos.top() > start_pos.top() + start_pos.height():
-                    painter.drawRect(QRect(0, start_pos.top() + start_pos.height(),
-                                         self.viewport().width(),
-                                         end_pos.top() - (start_pos.top() + start_pos.height())))
-                
-                # Last line
-                painter.drawRect(QRect(0, end_pos.top(), end_pos.right(), end_pos.height()))
-            
-            painter.end()
-
-    def focusInEvent(self, event):
-        super().focusInEvent(event)
-        # Show temporary hint in status bar when editor gets focus
-        if hasattr(self.parent(), 'statusBar'):
-            self.parent().parent().parent().statusBar().showMessage('Press Ctrl+Space for autocomplete', 2000)
-
-    def toggle_comment(self):
-        cursor = self.textCursor()
-        if cursor.hasSelection():
-            # Get the selected text
-            start = cursor.selectionStart()
-            end = cursor.selectionEnd()
-            
-            # Remember the selection
-            cursor.setPosition(start)
-            start_block = cursor.blockNumber()
-            cursor.setPosition(end)
-            end_block = cursor.blockNumber()
-            
-            # Process each line in the selection
-            cursor.setPosition(start)
-            cursor.beginEditBlock()
-            
-            for _ in range(start_block, end_block + 1):
-                # Move to start of line
-                cursor.movePosition(cursor.MoveOperation.StartOfLine)
-                
-                # Check if the line is already commented
-                line_text = cursor.block().text().lstrip()
-                if line_text.startswith('--'):
-                    # Remove comment
-                    pos = cursor.block().text().find('--')
-                    cursor.setPosition(cursor.block().position() + pos)
-                    cursor.deleteChar()
-                    cursor.deleteChar()
-                else:
-                    # Add comment
-                    cursor.insertText('--')
-                
-                # Move to next line if not at the end
-                if not cursor.atEnd():
-                    cursor.movePosition(cursor.MoveOperation.NextBlock)
-            
-            cursor.endEditBlock()
-        else:
-            # Comment/uncomment current line
-            cursor.movePosition(cursor.MoveOperation.StartOfLine)
-            cursor.movePosition(cursor.MoveOperation.EndOfLine, cursor.MoveMode.KeepAnchor)
-            line_text = cursor.selectedText().lstrip()
-            
-            cursor.movePosition(cursor.MoveOperation.StartOfLine)
-            if line_text.startswith('--'):
-                # Remove comment
-                pos = cursor.block().text().find('--')
-                cursor.setPosition(cursor.block().position() + pos)
-                cursor.deleteChar()
-                cursor.deleteChar()
-            else:
-                # Add comment
-                cursor.insertText('--')
-
-    def line_number_area_width(self):
-        digits = 1
-        max_num = max(1, self.blockCount())
-        while max_num >= 10:
-            max_num //= 10
-            digits += 1
-        
-        space = 3 + self.fontMetrics().horizontalAdvance('9') * digits
-        return space
-
-    def update_line_number_area_width(self, _):
-        self.setViewportMargins(self.line_number_area_width(), 0, 0, 0)
-
-    def update_line_number_area(self, rect, dy):
-        if dy:
-            self.line_number_area.scroll(0, dy)
-        else:
-            self.line_number_area.update(0, rect.y(), self.line_number_area.width(), rect.height())
-        
-        if rect.contains(self.viewport().rect()):
-            self.update_line_number_area_width(0)
-
-    def resizeEvent(self, event):
-        super().resizeEvent(event)
-        cr = self.contentsRect()
-        self.line_number_area.setGeometry(QRect(cr.left(), cr.top(), self.line_number_area_width(), cr.height()))
-
-    def line_number_area_paint_event(self, event):
-        painter = QPainter(self.line_number_area)
-        painter.fillRect(event.rect(), QColor("#f0f0f0"))  # Light gray background
-        
-        block = self.firstVisibleBlock()
-        block_number = block.blockNumber()
-        top = round(self.blockBoundingGeometry(block).translated(self.contentOffset()).top())
-        bottom = top + round(self.blockBoundingRect(block).height())
-        
-        while block.isValid() and top <= event.rect().bottom():
-            if block.isVisible() and bottom >= event.rect().top():
-                number = str(block_number + 1)
-                painter.setPen(QColor("#808080"))  # Gray text
-                painter.drawText(0, top, self.line_number_area.width() - 5, 
-                                self.fontMetrics().height(),
-                                Qt.AlignmentFlag.AlignRight, number)
-            
-            block = block.next()
-            top = bottom
-            bottom = top + round(self.blockBoundingRect(block).height())
-            block_number += 1
+        # 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.current_db_type = 'duckdb'  # Default to DuckDB
-        self.conn = duckdb.connect(':memory:')  # Create in-memory DuckDB connection by default
-        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 = {
@@ -514,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"""
@@ -658,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;
@@ -672,7 +365,112 @@ 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()
+        file_menu = menubar.addMenu('&File')
+        
+        # Project management actions
+        new_project_action = file_menu.addAction('New Project')
+        new_project_action.setShortcut('Ctrl+N')
+        new_project_action.triggered.connect(self.new_project)
+        
+        open_project_action = file_menu.addAction('Open Project...')
+        open_project_action.setShortcut('Ctrl+O')
+        open_project_action.triggered.connect(self.open_project)
+        
+        # Add Recent Projects submenu
+        self.recent_projects_menu = file_menu.addMenu('Recent Projects')
+        self.update_recent_projects_menu()
+        
+        save_project_action = file_menu.addAction('Save Project')
+        save_project_action.setShortcut('Ctrl+S')
+        save_project_action.triggered.connect(self.save_project)
+        
+        save_project_as_action = file_menu.addAction('Save Project As...')
+        save_project_as_action.setShortcut('Ctrl+Shift+S')
+        save_project_as_action.triggered.connect(self.save_project_as)
+        
+        file_menu.addSeparator()
+        
+        exit_action = file_menu.addAction('Exit')
+        exit_action.setShortcut('Ctrl+Q')
+        exit_action.triggered.connect(self.close)
+        
+        # Add View menu for window management
+        view_menu = menubar.addMenu('&View')
+        
+        # Maximized window option
+        maximize_action = view_menu.addAction('Maximize Window')
+        maximize_action.setShortcut('F11')
+        maximize_action.triggered.connect(self.toggle_maximize_window)
+        
+        # Zoom submenu
+        zoom_menu = view_menu.addMenu('Zoom')
+        
+        zoom_in_action = zoom_menu.addAction('Zoom In')
+        zoom_in_action.setShortcut('Ctrl++')
+        zoom_in_action.triggered.connect(lambda: self.change_zoom(1.1))
+        
+        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()
@@ -743,28 +541,16 @@ 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)
         left_layout.addWidget(self.tables_list)
         
         # 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)
@@ -776,198 +562,203 @@ 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)
-        self.results_table.horizontalHeader().setStretchLastSection(True)
-        self.results_table.horizontalHeader().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
+            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 = 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
+            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")
+                return
+                
+            # Set up the table dimensions
+            row_count = len(df)
+            col_count = len(df.columns)
+            current_tab.results_table.setColumnCount(col_count)
+            
+            # Set column headers
+            headers = [str(col) for col in df.columns]
+            current_tab.results_table.setHorizontalHeaderLabels(headers)
+            
+            # Calculate chunk size (adjust based on available memory)
+            CHUNK_SIZE = 1000
+            
+            # Process data in chunks to avoid memory issues with large datasets
+            for chunk_start in range(0, row_count, CHUNK_SIZE):
+                chunk_end = min(chunk_start + CHUNK_SIZE, row_count)
+                chunk = df.iloc[chunk_start:chunk_end]
+                
+                # Add rows for this chunk
+                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)
+                        current_tab.results_table.setItem(row_idx, col_idx, item)
+                        
+                # Process events to keep UI responsive
+                QApplication.processEvents()
+            
+            # Optimize column widths
+            current_tab.results_table.resizeColumnsToContents()
+            
+            # Restore bar charts for columns that previously had them
+            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(
+                f"Loaded {row_count:,} rows, {col_count} columns. Memory usage: {memory_usage:.1f} MB"
+            )
+            
+        except Exception as e:
+            QMessageBox.critical(self, "Error",
+                f"Failed to populate results table:\n\n{str(e)}")
+            self.statusBar().showMessage("Failed to display results")
+
+    def apply_filters(self):
+        """Apply filters to the table based on filter inputs"""
+        if self.current_df is None or not self.filter_widgets:
+            return
+            
+        try:
+            # Start with the original DataFrame
+            filtered_df = self.current_df.copy()
+            
+            # Apply each non-empty filter
+            for col_idx, filter_widget in enumerate(self.filter_widgets):
+                filter_text = filter_widget.text().strip()
+                if filter_text:
+                    col_name = self.current_df.columns[col_idx]
+                    # Convert column to string for filtering
+                    filtered_df[col_name] = filtered_df[col_name].astype(str)
+                    filtered_df = filtered_df[filtered_df[col_name].str.contains(filter_text, case=False, na=False)]
+            
+            # Update table with filtered data
+            row_count = len(filtered_df)
+            for row_idx in range(row_count):
+                for col_idx, value in enumerate(filtered_df.iloc[row_idx]):
+                    formatted_value = self.format_value(value)
+                    item = QTableWidgetItem(formatted_value)
+                    self.results_table.setItem(row_idx, col_idx, item)
+            
+            # Hide rows that don't match filter
+            for row_idx in range(row_count + 1, self.results_table.rowCount()):
+                self.results_table.hideRow(row_idx)
+            
+            # Show all filtered rows
+            for row_idx in range(1, row_count + 1):
+                self.results_table.showRow(row_idx)
+            
+            # Update status
+            self.statusBar().showMessage(f"Showing {row_count:,} rows after filtering")
+            
+        except Exception as e:
+            self.statusBar().showMessage(f"Error applying filters: {str(e)}")
 
     def format_value(self, value):
-        """Format values for display"""
+        """Format cell values efficiently"""
         if pd.isna(value):
-            return 'NULL'
-        elif isinstance(value, (int, np.integer)):
-            return f"{value:,}"
+            return "NULL"
         elif isinstance(value, (float, np.floating)):
-            return f"{value:,.2f}"
-        elif isinstance(value, (datetime, pd.Timestamp)):
-            return value.strftime('%Y-%m-%d %H:%M:%S')
+            if value.is_integer():
+                return str(int(value))
+            return f"{value:.6g}"  # Use general format with up to 6 significant digits
+        elif isinstance(value, (pd.Timestamp, datetime)):
+            return value.strftime("%Y-%m-%d %H:%M:%S")
+        elif isinstance(value, (np.integer, int)):
+            return str(value)
+        elif isinstance(value, bool):
+            return str(value)
+        elif isinstance(value, (bytes, bytearray)):
+            return value.hex()
         return str(value)
 
-    def populate_table(self, df):
-        """Populate the table widget with DataFrame content"""
-        if len(df) == 0:
-            self.results_table.setRowCount(0)
-            self.results_table.setColumnCount(0)
-            self.row_count_label.setText("No results")
-            return
-
-        # Set dimensions
-        self.results_table.setRowCount(len(df))
-        self.results_table.setColumnCount(len(df.columns))
-        
-        # Set headers
-        self.results_table.setHorizontalHeaderLabels(df.columns)
-        
-        # Populate data
-        for i, (_, row) in enumerate(df.iterrows()):
-            for j, value in enumerate(row):
-                formatted_value = self.format_value(value)
-                item = QTableWidgetItem(formatted_value)
-                
-                # Set alignment based on data type
-                if isinstance(value, (int, float, np.integer, np.floating)):
-                    item.setTextAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
-                else:
-                    item.setTextAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
-                
-                # Make cells read-only
-                item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEditable)
-                
-                # Apply special styling for NULL values
-                if pd.isna(value):
-                    item.setForeground(QColor(self.colors['text_light']))
-                    item.setBackground(QColor("#F8F9FA"))
-                
-                self.results_table.setItem(i, j, item)
-        
-        # Auto-adjust column widths while ensuring minimum and maximum sizes
-        self.results_table.resizeColumnsToContents()
-        for i in range(len(df.columns)):
-            width = self.results_table.columnWidth(i)
-            self.results_table.setColumnWidth(i, min(max(width, 80), 300))
-        
-        # Update row count
-        row_text = "row" if len(df) == 1 else "rows"
-        self.row_count_label.setText(f"{len(df):,} {row_text}")
-        
-        # Apply zebra striping
-        for i in range(len(df)):
-            if i % 2 == 0:
-                for j in range(len(df.columns)):
-                    item = self.results_table.item(i, j)
-                    if item and not pd.isna(df.iloc[i, j]):
-                        item.setBackground(QColor("#FFFFFF"))
-            else:
-                for j in range(len(df.columns)):
-                    item = self.results_table.item(i, j)
-                    if item and not pd.isna(df.iloc[i, j]):
-                        item.setBackground(QColor("#F8F9FA"))
-
     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_db_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,
@@ -978,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_db_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)})")
@@ -1035,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}"')
@@ -1066,213 +812,380 @@ class SQLShell(QMainWindow):
                 self.update_completer()
 
     def open_database(self):
-        """Open a database file (DuckDB or SQLite)"""
-        file_name, _ = QFileDialog.getOpenFileName(
-            self,
-            "Open Database File",
-            "",
-            "Database Files (*.db);;All Files (*)"
-        )
-        
-        if not file_name:
-            return
+        """Open a database connection with proper error handling and resource management"""
+        try:
+            filename, _ = QFileDialog.getOpenFileName(
+                self,
+                "Open Database",
+                "",
+                "All Database Files (*.db *.sqlite *.sqlite3);;All Files (*)"
+            )
             
+            if filename:
+                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)
+                    
+                    # Use the database manager to open the database
+                    self.db_manager.open_database(filename)
+                    
+                    # 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:
+            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 in a non-blocking way"""
         try:
-            # Try to detect database type
-            is_sqlite = self.is_sqlite_db(file_name)
+            # Check if any tabs exist
+            if self.tab_widget.count() == 0:
+                return
             
-            # Close existing connection if any
-            if self.conn:
-                self.conn.close()
+            # Start a background update with a timer
+            self.statusBar().showMessage("Updating auto-completion...", 2000)
             
-            # Connect to the database
-            if is_sqlite:
-                self.conn = sqlite3.connect(file_name)
-                self.current_db_type = 'sqlite'
-            else:
-                self.conn = duckdb.connect(file_name)
-                self.current_db_type = 'duckdb'
+            # Track query history and frequently used terms
+            if not hasattr(self, 'query_history'):
+                self.query_history = []
+                self.completion_usage = {}  # Track usage frequency
             
-            # Clear existing tables
-            self.loaded_tables.clear()
-            self.tables_list.clear()
+            # 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]
             
-            # Load tables
-            self.load_database_tables()
+            # Use a single model for all tabs to save memory and improve performance
+            model = QStringListModel(completion_words)
             
-            # Update UI
-            db_type = "SQLite" if is_sqlite else "DuckDB"
-            self.db_info_label.setText(f"Connected to: {os.path.basename(file_name)} ({db_type})")
-            self.statusBar().showMessage(f'Successfully opened {db_type} database: {file_name}')
+            # Keep a reference to the model to prevent garbage collection
+            self._current_completer_model = model
             
-        except Exception as e:
-            QMessageBox.critical(self, "Error", f"Failed to open database: {str(e)}")
-            self.statusBar().showMessage('Error opening database')
-
-    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_db_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)")
-                    
-                    # 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)")
-                    
-                    # Get column names for each table
+            # 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:
-                        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()
+                        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:
-            self.statusBar().showMessage(f'Error loading tables: {str(e)}')
-
-    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])
+            # Catch any errors to prevent hanging
+            self.statusBar().showMessage(f"Auto-completion update error: {str(e)}", 2000)
+            return False
             
-        # Update the completer in the query editor
-        self.query_edit.update_completer_model(completion_words)
+    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):
-        query = self.query_edit.toPlainText().strip()
-        if not query:
-            return
-        
-        if not self.conn:
-            QMessageBox.warning(self, "No Connection", "No database connection available. Creating an in-memory DuckDB database.")
-            self.conn = duckdb.connect(':memory:')
-            self.current_db_type = 'duckdb'
-            self.db_info_label.setText("Connected to: in-memory DuckDB")
-        
-        # Show loading indicator in status bar
-        self.statusBar().showMessage('Executing query...')
-        
         try:
-            # Reset results title
-            results_title = self.findChild(QLabel, "header_label", Qt.FindChildOption.FindChildrenRecursively)
-            if results_title:
-                results_title.setText("RESULTS")
-            
-            if self.current_db_type == 'sqlite':
-                # Execute SQLite query and convert to DataFrame
-                result = pd.read_sql_query(query, self.conn)
-            else:
-                # Execute DuckDB query
-                result = self.conn.execute(query).fetchdf()
+            # Get the current tab
+            current_tab = self.get_current_tab()
+            if not current_tab:
+                return
                 
-            self.populate_table(result)
-            
-            # Show success message with query stats
-            execution_time = datetime.now().strftime("%H:%M:%S")
-            row_count = len(result)
-            self.statusBar().showMessage(f'Query executed successfully at {execution_time} - {row_count:,} rows returned')
+            query = current_tab.get_query_text().strip()
+            if not query:
+                QMessageBox.warning(self, "Empty Query", "Please enter a SQL query to execute.")
+                return
+
+            start_time = datetime.now()
             
+            try:
+                # 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)}")
+                
+                # 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:
-            self.results_table.setRowCount(0)
-            self.results_table.setColumnCount(0)
-            self.row_count_label.setText("Error")
-            self.statusBar().showMessage('Error executing query')
-            
-            # Show error message with modern styling
-            error_msg = str(e)
-            if "not found" in error_msg.lower():
-                error_msg += "\nMake sure the table name is correct and the table is loaded."
-            elif "syntax error" in error_msg.lower():
-                error_msg += "\nPlease check your SQL syntax."
-                
-            error_box = QMessageBox(self)
-            error_box.setIcon(QMessageBox.Icon.Critical)
-            error_box.setWindowTitle("Query Error")
-            error_box.setText("Error executing query")
-            error_box.setInformativeText(error_msg)
-            error_box.setDetailedText(f"Query:\n{query}")
-            error_box.setStandardButtons(QMessageBox.StandardButton.Ok)
-            error_box.exec()
+            QMessageBox.critical(self, "Unexpected Error",
+                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_db_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.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...')
             
@@ -1289,45 +1202,30 @@ 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 
-    s.orderid,
-    s.orderdate,
-    c.customername,
-    p.productname,
-    s.quantity,
-    s.unitprice,
-    (s.quantity * s.unitprice) AS total_amount
+    DISTINCT
+    c.customername     
 FROM 
     sample_sales_data s
     INNER JOIN customer_data c ON c.customerid = s.customerid
     INNER JOIN product_catalog p ON p.productid = s.productid
-ORDER BY 
-    s.orderdate DESC
 LIMIT 10
 """
-            self.query_edit.setPlainText(sample_query.strip())
+                current_tab.set_query_text(sample_query.strip())
             
             # Update completer
             self.update_completer()
@@ -1343,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
         
@@ -1359,13 +1262,36 @@ LIMIT 10
             df = self.get_table_data_as_dataframe()
             df.to_excel(file_name, index=False)
             
-            self.statusBar().showMessage(f'Data exported to {file_name}')
+            # Generate table name from file name
+            base_name = os.path.splitext(os.path.basename(file_name))[0]
+            table_name = self.db_manager.sanitize_table_name(base_name)
+            
+            # Ensure unique table name
+            original_name = table_name
+            counter = 1
+            while table_name in self.db_manager.loaded_tables:
+                table_name = f"{original_name}_{counter}"
+                counter += 1
+            
+            # Register the table in the database manager
+            self.db_manager.register_dataframe(df, table_name, file_name)
+            
+            # Update tracking
+            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)})")
+            self.statusBar().showMessage(f'Data exported to {file_name} and loaded as table "{table_name}"')
+            
+            # Update completer with new table and column names
+            self.update_completer()
             
             # Show success message
             QMessageBox.information(
                 self, 
                 "Export Successful", 
-                f"Data has been exported to:\n{file_name}",
+                f"Data has been exported to:\n{file_name}\nand loaded as table: {table_name}",
                 QMessageBox.StandardButton.Ok
             )
         except Exception as e:
@@ -1373,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
         
@@ -1389,13 +1320,36 @@ LIMIT 10
             df = self.get_table_data_as_dataframe()
             df.to_parquet(file_name, index=False)
             
-            self.statusBar().showMessage(f'Data exported to {file_name}')
+            # Generate table name from file name
+            base_name = os.path.splitext(os.path.basename(file_name))[0]
+            table_name = self.db_manager.sanitize_table_name(base_name)
+            
+            # Ensure unique table name
+            original_name = table_name
+            counter = 1
+            while table_name in self.db_manager.loaded_tables:
+                table_name = f"{original_name}_{counter}"
+                counter += 1
+            
+            # Register the table in the database manager
+            self.db_manager.register_dataframe(df, table_name, file_name)
+            
+            # Update tracking
+            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)})")
+            self.statusBar().showMessage(f'Data exported to {file_name} and loaded as table "{table_name}"')
+            
+            # Update completer with new table and column names
+            self.update_completer()
             
             # Show success message
             QMessageBox.information(
                 self, 
                 "Export Successful", 
-                f"Data has been exported to:\n{file_name}",
+                f"Data has been exported to:\n{file_name}\nand loaded as table: {table_name}",
                 QMessageBox.StandardButton.Ok
             )
         except Exception as e:
@@ -1404,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)
@@ -1418,56 +1377,1040 @@ 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)
 
+    def closeEvent(self, event):
+        """Ensure proper cleanup of database connections when closing the application"""
+        try:
+            # Check for unsaved changes
+            if self.has_unsaved_changes():
+                reply = QMessageBox.question(self, 'Save Changes',
+                    'Do you want to save your changes before closing?',
+                    QMessageBox.StandardButton.Save | 
+                    QMessageBox.StandardButton.Discard | 
+                    QMessageBox.StandardButton.Cancel)
+                
+                if reply == QMessageBox.StandardButton.Save:
+                    self.save_project()
+                elif reply == QMessageBox.StandardButton.Cancel:
+                    event.ignore()
+                    return
+            
+            # Save window state and settings
+            self.save_recent_projects()
+            
+            # Close database connections
+            self.db_manager.close_connection()
+            event.accept()
+        except Exception as e:
+            QMessageBox.warning(self, "Cleanup Warning", 
+                f"Warning: Could not properly close database connection:\n{str(e)}")
+            event.accept()
+
+    def has_unsaved_changes(self):
+        """Check if there are unsaved changes in the project"""
+        if not self.current_project_file:
+            return (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.db_manager.table_columns.get(name, [])
+                    }
+                    for name, path in self.db_manager.loaded_tables.items()
+                },
+                'tabs': current_tabs_data,
+                'connection_type': self.db_manager.connection_type
+            }
+            
+            # 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
+            return True
+
+    def show_tables_context_menu(self, position):
+        """Show context menu for tables list"""
+        item = self.tables_list.itemAt(position)
+        if not item:
+            return
+
+        # Get 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]
+
+        # Create context menu
+        context_menu = QMenu(self)
+        context_menu.setStyleSheet("""
+            QMenu {
+                background-color: white;
+                border: 1px solid #BDC3C7;
+                padding: 5px;
+            }
+            QMenu::item {
+                padding: 5px 20px;
+            }
+            QMenu::item:selected {
+                background-color: #3498DB;
+                color: white;
+            }
+        """)
+
+        # Add menu actions
+        select_from_action = context_menu.addAction("Select from")
+        add_to_editor_action = context_menu.addAction("Just add to editor")
+        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 = current_tab.query_edit.textCursor()
+            cursor.insertText(f"SELECT * FROM {table_name}")
+            current_tab.query_edit.setFocus()
+        elif action == add_to_editor_action:
+            # Just insert the table name at cursor position
+            cursor = current_tab.query_edit.textCursor()
+            cursor.insertText(table_name)
+            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.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
+                self.db_manager.close_connection()
+                
+                # Reset state
+                self.tables_list.clear()
+                
+                # Clear all tabs except one
+                while self.tab_widget.count() > 1:
+                    self.close_tab(1)  # Always close tab at index 1 to keep at least one tab
+                
+                # Clear the remaining tab
+                first_tab = self.get_tab_at_index(0)
+                if first_tab:
+                    first_tab.set_query_text("")
+                    first_tab.results_table.setRowCount(0)
+                    first_tab.results_table.setColumnCount(0)
+                    first_tab.row_count_label.setText("")
+                    first_tab.results_title.setText("RESULTS")
+                
+                self.current_project_file = None
+                self.setWindowTitle('SQL Shell')
+                self.db_info_label.setText("No database connected")
+                self.statusBar().showMessage('New project created')
+
+    def save_project(self):
+        """Save the current project"""
+        if not self.current_project_file:
+            self.save_project_as()
+            return
+            
+        self.save_project_to_file(self.current_project_file)
+
+    def save_project_as(self):
+        """Save the current project to a new file"""
+        file_name, _ = QFileDialog.getSaveFileName(
+            self,
+            "Save Project",
+            "",
+            "SQL Shell Project (*.sqls);;All Files (*)"
+        )
+        
+        if file_name:
+            if not file_name.endswith('.sqls'):
+                file_name += '.sqls'
+            self.save_project_to_file(file_name)
+            self.current_project_file = file_name
+            self.setWindowTitle(f'SQL Shell - {os.path.basename(file_name)}')
+
+    def save_project_to_file(self, file_name):
+        """Save project data to a file"""
+        try:
+            # 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': {},
+                '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.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
+                else:
+                    # For file-based tables, store the absolute path
+                    source_path = os.path.abspath(file_path)
+                
+                project_data['tables'][table_name] = {
+                    'file_path': source_path,
+                    'columns': self.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, file_name=None):
+        """Open a project file"""
+        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.")
+                
+                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.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':
+                            # 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.db_manager.loaded_tables[table_name] = 'query_result'
+                            self.tables_list.addItem(f"{table_name} (query result)")
+                        elif os.path.exists(file_path):
+                            # Use the database manager to load the file
+                            try:
+                                loaded_table_name, df = self.db_manager.load_file(file_path)
+                                self.tables_list.addItem(f"{loaded_table_name} ({os.path.basename(file_path)})")
+                            except Exception as e:
+                                QMessageBox.warning(self, "Warning",
+                                    f"Failed to load file for table {table_name}:\n{str(e)}")
+                                continue
+                        else:
+                            QMessageBox.warning(self, "Warning",
+                                f"Could not find file for table {table_name}: {file_path}")
+                            continue
+                            
+                    except Exception as e:
+                        QMessageBox.warning(self, "Warning",
+                            f"Failed to load table {table_name}:\n{str(e)}")
+                
+                    # Update progress for this table
+                    current_progress += table_progress_step
+                    progress.setValue(int(current_progress))
+                    QApplication.processEvents()  # Keep UI responsive
+                
+                # If the project had database tables but we couldn't connect automatically, notify the user
+                if has_database_tables and not database_tables_loaded:
+                    QMessageBox.information(self, "Database Connection Required",
+                        "This project contains database tables. You need to reconnect to the database to use them.\n\n"
+                        "Use the 'Open Database' button to connect to your database file.")
+                
+                # Check if the operation was canceled
+                if progress.wasCanceled():
+                    self.statusBar().showMessage("Project loading was canceled")
+                    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}')
+                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 style
-    app.setStyle('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))
     
-    # Apply custom palette for the entire application
-    palette = QPalette()
-    palette.setColor(QPalette.ColorRole.Window, QColor("#ECF0F1"))
-    palette.setColor(QPalette.ColorRole.WindowText, QColor("#2C3E50"))
-    palette.setColor(QPalette.ColorRole.Base, QColor("#FFFFFF"))
-    palette.setColor(QPalette.ColorRole.AlternateBase, QColor("#F5F5F5"))
-    palette.setColor(QPalette.ColorRole.ToolTipBase, QColor("#2C3E50"))
-    palette.setColor(QPalette.ColorRole.ToolTipText, QColor("#FFFFFF"))
-    palette.setColor(QPalette.ColorRole.Text, QColor("#2C3E50"))
-    palette.setColor(QPalette.ColorRole.Button, QColor("#3498DB"))
-    palette.setColor(QPalette.ColorRole.ButtonText, QColor("#FFFFFF"))
-    palette.setColor(QPalette.ColorRole.BrightText, QColor("#FFFFFF"))
-    palette.setColor(QPalette.ColorRole.Link, QColor("#3498DB"))
-    palette.setColor(QPalette.ColorRole.Highlight, QColor("#3498DB"))
-    palette.setColor(QPalette.ColorRole.HighlightedText, QColor("#FFFFFF"))
-    app.setPalette(palette)
+    # Ensure we have a valid working directory with pool.db
+    package_dir = os.path.dirname(os.path.abspath(__file__))
+    working_dir = os.getcwd()
     
-    # Set default font
-    default_font = QFont("Segoe UI", 10)
-    app.setFont(default_font)
-    
-    # Create and show the application
-    sql_shell = SQLShell()
+    # If pool.db doesn't exist in current directory, copy it from package
+    if not os.path.exists(os.path.join(working_dir, 'pool.db')):
+        import shutil
+        package_db = os.path.join(package_dir, 'pool.db')
+        if os.path.exists(package_db):
+            shutil.copy2(package_db, working_dir)
+        else:
+            package_db = os.path.join(os.path.dirname(package_dir), 'pool.db')
+            if os.path.exists(package_db):
+                shutil.copy2(package_db, working_dir)
     
-    # Set application icon (if available)
     try:
-        app_icon = QIcon("sqlshell/resources/icon.png")
-        sql_shell.setWindowIcon(app_icon)
-    except:
-        # If icon not found, continue without it
-        pass
-    
-    sql_shell.show()
-    sys.exit(app.exec())
+        # 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()
+        sys.exit(app.exec())
 
 if __name__ == '__main__':
     main()