sqlbench 0.1.56__tar.gz → 0.1.59__tar.gz

{sqlbench-0.1.56 → sqlbench-0.1.59}/CLAUDE.md

@@ -1,4 +1,5 @@
 # Claude Code Instructions
 
-## Git Commits
+## Git
+- NEVER run git commands (add, commit, push, tag, etc.) unless the user explicitly asks
 - NEVER mention Claude, AI, or include Co-Authored-By lines in git commit messages

{sqlbench-0.1.56 → sqlbench-0.1.59}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbench
-Version: 0.1.56
+Version: 0.1.59
 Summary: A multi-database SQL workbench with support for IBM i, MySQL, and PostgreSQL
 Project-URL: Homepage, https://github.com/jpsteil/sqlbench
 Project-URL: Repository, https://github.com/jpsteil/sqlbench

{sqlbench-0.1.56 → sqlbench-0.1.59}/sqlbench/qt/connection_tree.py

@@ -38,8 +38,7 @@ class ConnectionTreeWidget(QWidget):
     show_rows_requested = pyqtSignal(str, str, str)  # connection, schema, table
     edit_connection_requested = pyqtSignal(str)  # connection_name
     new_connection_requested = pyqtSignal()
-    connect_requested = pyqtSignal(str)  # connection_name
-    disconnect_requested = pyqtSignal(str)  # connection_name
+    connect_requested = pyqtSignal(str)  # connection_name (auto-activate on expand)
 
     def __init__(self, parent: Optional[QWidget] = None):
         super().__init__(parent)
@@ -130,12 +129,6 @@ class ConnectionTreeWidget(QWidget):
         """Set up right-click context menu."""
         self.context_menu = QMenu(self)
 
-        self.action_connect = QAction("Connect", self)
-        self.action_connect.triggered.connect(self._connect_selected)
-
-        self.action_disconnect = QAction("Disconnect", self)
-        self.action_disconnect.triggered.connect(self._disconnect_selected)
-
         self.action_new_sql = QAction("New SQL", self)
         self.action_new_sql.triggered.connect(self._new_sql_for_selected)
 
@@ -173,7 +166,9 @@ class ConnectionTreeWidget(QWidget):
         self._connections_info[name] = conn
         self._connected[name] = False
 
-        item = QTreeWidgetItem([name])
+        host = conn.get('host', '')
+        display_name = f"{name} - {host}" if host else name
+        item = QTreeWidgetItem([display_name])
         item.setData(0, Qt.ItemDataRole.UserRole, {
             'type': 'connection',
             'name': name,
@@ -193,29 +188,31 @@ class ConnectionTreeWidget(QWidget):
         return item
 
     def set_connected(self, connection_name: str, connected: bool) -> None:
-        """Update connection status."""
+        """Update connection activation status."""
         self._connected[connection_name] = connected
 
-        # Update item text
-        for i in range(self.tree.topLevelItemCount()):
-            item = self.tree.topLevelItem(i)
-            data = item.data(0, Qt.ItemDataRole.UserRole)
-            if data and data.get('name') == connection_name:
-                if connected:
-                    item.setText(0, f"{connection_name} (connected)")
-                    # Expand if this was pending from double-click
-                    if hasattr(self, '_pending_expand') and self._pending_expand == item:
-                        item.setExpanded(True)
-                        self._pending_expand = None
-                else:
-                    item.setText(0, connection_name)
-                    # Clear children
+        if not connected:
+            # Clear cached schemas
+            for i in range(self.tree.topLevelItemCount()):
+                item = self.tree.topLevelItem(i)
+                data = item.data(0, Qt.ItemDataRole.UserRole)
+                if data and data.get('name') == connection_name:
                     item.takeChildren()
                     placeholder = QTreeWidgetItem(["Loading..."])
                     placeholder.setData(0, Qt.ItemDataRole.UserRole, {'type': 'placeholder'})
                     item.addChild(placeholder)
                     self._loaded_schemas[connection_name] = False
-                break
+                    break
+        else:
+            # Expand if pending from expand attempt
+            if self._pending_expand:
+                for i in range(self.tree.topLevelItemCount()):
+                    item = self.tree.topLevelItem(i)
+                    data = item.data(0, Qt.ItemDataRole.UserRole)
+                    if data and data.get('name') == connection_name and item == self._pending_expand:
+                        item.setExpanded(True)
+                        self._pending_expand = None
+                        break
 
     def _on_item_expanded(self, item: QTreeWidgetItem) -> None:
         """Handle item expansion - load children if needed."""
@@ -541,14 +538,7 @@ class ConnectionTreeWidget(QWidget):
 
         if item_type == 'connection':
             connection_name = data.get('name')
-            is_connected = self._connected.get(connection_name, False)
-
-            if is_connected:
-                menu.addAction(self.action_disconnect)
-            else:
-                menu.addAction(self.action_connect)
 
-            menu.addSeparator()
             menu.addAction(self.action_new_sql)
 
             # Check if IBM i for spool files
@@ -576,16 +566,7 @@ class ConnectionTreeWidget(QWidget):
 
         item_type = data.get('type')
 
-        if item_type == 'connection':
-            connection_name = data.get('name')
-            if not self._connected.get(connection_name):
-                self.connect_requested.emit(connection_name)
-                # Store item to expand after connect succeeds
-                self._pending_expand = item
-            else:
-                item.setExpanded(not item.isExpanded())
-
-        elif item_type in ('schema', 'table'):
+        if item_type in ('connection', 'schema', 'table'):
             item.setExpanded(not item.isExpanded())
 
     def _on_current_changed(self, current: QTreeWidgetItem,
@@ -609,22 +590,6 @@ class ConnectionTreeWidget(QWidget):
         else:
             return data.get('connection')
 
-    def _connect_selected(self) -> None:
-        """Connect the selected connection."""
-        item = self.tree.currentItem()
-        if item:
-            connection_name = self._get_connection_for_item(item)
-            if connection_name:
-                self.connect_requested.emit(connection_name)
-
-    def _disconnect_selected(self) -> None:
-        """Disconnect the selected connection."""
-        item = self.tree.currentItem()
-        if item:
-            connection_name = self._get_connection_for_item(item)
-            if connection_name:
-                self.disconnect_requested.emit(connection_name)
-
     def _new_sql_for_selected(self) -> None:
         """Create new SQL tab for selected connection."""
         item = self.tree.currentItem()
@@ -707,14 +672,6 @@ class ConnectionTreeWidget(QWidget):
             elif item.parent():
                 self.tree.setCurrentItem(item.parent())
         elif key in (Qt.Key.Key_Return, Qt.Key.Key_Space):
-            data = item.data(0, Qt.ItemDataRole.UserRole)
-            if data:
-                if data.get('type') == 'connection':
-                    if not self._connected.get(data.get('name')):
-                        self.connect_requested.emit(data.get('name'))
-                    else:
-                        item.setExpanded(not item.isExpanded())
-                else:
-                    item.setExpanded(not item.isExpanded())
+            item.setExpanded(not item.isExpanded())
         else:
             super().keyPressEvent(event)

{sqlbench-0.1.56 → sqlbench-0.1.59}/sqlbench/qt/dialogs/connection_dialog.py

@@ -91,12 +91,14 @@ class ConnectionDialog(QDialog):
         self.btn_new = QPushButton("+")
         self.btn_new.setFixedWidth(32)
         self.btn_new.setToolTip("New connection")
+        self.btn_new.setAutoDefault(False)
         self.btn_new.clicked.connect(self._new_connection)
         btn_layout.addWidget(self.btn_new)
 
         self.btn_delete = QPushButton("−")
         self.btn_delete.setFixedWidth(32)
         self.btn_delete.setToolTip("Delete connection")
+        self.btn_delete.setAutoDefault(False)
         self.btn_delete.clicked.connect(self._delete_connection)
         btn_layout.addWidget(self.btn_delete)
 
@@ -170,6 +172,11 @@ class ConnectionDialog(QDialog):
         self.txt_password.setPlaceholderText("password")
         form_layout.addRow("Password:", self.txt_password)
 
+        # Enter key in any field triggers Save
+        for field in (self.txt_name, self.txt_host, self.txt_port,
+                      self.txt_database, self.txt_user, self.txt_password):
+            field.returnPressed.connect(self._save_connection)
+
         # Options
         options_layout = QVBoxLayout()
 
@@ -194,6 +201,7 @@ class ConnectionDialog(QDialog):
         btn_layout = QHBoxLayout()
 
         self.btn_test = QPushButton("Test Connection")
+        self.btn_test.setAutoDefault(False)
         self.btn_test.clicked.connect(self._test_connection)
         btn_layout.addWidget(self.btn_test)
 
@@ -201,10 +209,12 @@ class ConnectionDialog(QDialog):
 
         self.btn_save = QPushButton("Save")
         self.btn_save.setProperty("primary", True)
+        self.btn_save.setDefault(True)
         self.btn_save.clicked.connect(self._save_connection)
         btn_layout.addWidget(self.btn_save)
 
         self.btn_close = QPushButton("Close")
+        self.btn_close.setAutoDefault(False)
         self.btn_close.clicked.connect(self.accept)
         btn_layout.addWidget(self.btn_close)
 
@@ -251,7 +261,7 @@ class ConnectionDialog(QDialog):
 
         self.txt_name.setText(conn.get('name', ''))
         self.txt_host.setText(conn.get('host', ''))
-        self.txt_port.setText(str(conn.get('port', '')))
+        self.txt_port.setText(str(conn['port']) if conn.get('port') else '')
         self.txt_database.setText(conn.get('database', ''))
         self.txt_user.setText(conn.get('user', ''))
         self.txt_password.setText(conn.get('password', ''))
@@ -284,15 +294,20 @@ class ConnectionDialog(QDialog):
     def _on_type_changed(self) -> None:
         """Handle database type change."""
         db_type = self.cmb_type.currentData()
+        adapter_cls = ADAPTERS.get(db_type)
 
-        # IBM i doesn't use port/database
-        is_ibmi = db_type == "ibmi"
+        has_port = adapter_cls.default_port is not None if adapter_cls else True
+        has_database = adapter_cls.requires_database if adapter_cls else True
 
         # Hide/show port and database fields with their labels
-        self.txt_port.setVisible(not is_ibmi)
-        self.txt_database.setVisible(not is_ibmi)
-        self.lbl_port.setVisible(not is_ibmi)
-        self.lbl_database.setVisible(not is_ibmi)
+        self.txt_port.setVisible(has_port)
+        self.lbl_port.setVisible(has_port)
+        self.txt_database.setVisible(has_database)
+        self.lbl_database.setVisible(has_database)
+
+        # Pre-fill default port if empty
+        if has_port and not self.txt_port.text().strip() and adapter_cls:
+            self.txt_port.setText(str(adapter_cls.default_port))
 
         # Show install button if driver not available
         adapters = get_available_adapters()
@@ -303,6 +318,7 @@ class ConnectionDialog(QDialog):
         import subprocess
         import sys
         import threading
+        from PyQt6.QtCore import QTimer
 
         db_type = self.cmb_type.currentData()
         adapter_cls = ADAPTERS.get(db_type)
@@ -317,23 +333,34 @@ class ConnectionDialog(QDialog):
 
         self.btn_install_driver.setEnabled(False)
         self.btn_install_driver.setText("Installing...")
+        self._install_result = None  # (success: bool, error: str or None)
 
         def do_install():
             try:
                 result = subprocess.run(
                     [sys.executable, "-m", "pip", "install", pkg],
-                    capture_output=True, text=True)
-                from PyQt6.QtCore import QTimer
+                    capture_output=True, text=True,
+                    stdin=subprocess.DEVNULL, timeout=120)
                 if result.returncode == 0:
-                    QTimer.singleShot(0, self._on_driver_installed)
+                    self._install_result = (True, None)
                 else:
                     error = result.stderr or result.stdout or "Unknown error"
-                    QTimer.singleShot(0, lambda: self._on_driver_install_failed(error))
+                    self._install_result = (False, error)
             except Exception as e:
-                from PyQt6.QtCore import QTimer
-                QTimer.singleShot(0, lambda: self._on_driver_install_failed(str(e)))
+                self._install_result = (False, str(e))
+
+        def poll_result():
+            if self._install_result is None:
+                QTimer.singleShot(500, poll_result)
+                return
+            success, error = self._install_result
+            if success:
+                self._on_driver_installed()
+            else:
+                self._on_driver_install_failed(error)
 
         threading.Thread(target=do_install, daemon=True).start()
+        QTimer.singleShot(2000, poll_result)
 
     def _on_driver_installed(self) -> None:
         """Handle successful driver installation."""
@@ -429,13 +456,20 @@ class ConnectionDialog(QDialog):
             return
 
         db_type = self.cmb_type.currentData()
-        port = self.txt_port.text()
+        port = self.txt_port.text().strip()
+
+        # Use adapter default port if blank
+        if not port or not port.isdigit():
+            adapter_cls = ADAPTERS.get(db_type)
+            port = adapter_cls.default_port if adapter_cls else None
+        else:
+            port = int(port)
 
         conn_data = {
             'name': name,
             'db_type': db_type,
             'host': self.txt_host.text(),
-            'port': int(port) if port else None,
+            'port': port,
             'database': self.txt_database.text(),
             'user': self.txt_user.text(),
             'password': self.txt_password.text(),

{sqlbench-0.1.56 → sqlbench-0.1.59}/sqlbench/qt/main_window.py

@@ -35,7 +35,8 @@ class MainWindow(QMainWindow):
     def __init__(self):
         super().__init__()
 
-        self.setWindowTitle("SQLBench")
+        from ..version import __version__
+        self.setWindowTitle(f"SQLBench v{__version__}")
         self.setMinimumSize(1024, 600)
 
         # Load theme preference
@@ -114,7 +115,6 @@ class MainWindow(QMainWindow):
         self.connection_tree = ConnectionTreeWidget()
         self.connection_tree.connection_selected.connect(self._on_connection_selected)
         self.connection_tree.connect_requested.connect(self._on_connect_requested)
-        self.connection_tree.disconnect_requested.connect(self._on_disconnect_requested)
         self.connection_tree.new_sql_requested.connect(self._on_new_sql_tab)
         self.connection_tree.new_spool_requested.connect(self._on_new_spool_tab)
         self.connection_tree.show_rows_requested.connect(self._on_show_rows)
@@ -315,8 +315,17 @@ class MainWindow(QMainWindow):
         from .dialogs.settings_dialog import SettingsDialog
         dialog = SettingsDialog(self)
         if dialog.exec():
-            # Apply settings
-            pass
+            self._apply_font_size()
+
+    def _apply_font_size(self) -> None:
+        """Apply current font size setting to all open tabs."""
+        from .tabs.sql_tab import SQLTab
+        size = int(get_setting("font_size", "13"))
+        for i in range(self.tab_container.count()):
+            tab = self.tab_container.widget(i)
+            if isinstance(tab, SQLTab):
+                tab.set_font_size(size)
+        self.status_bar.showMessage(f"Font size set to {size}", 3000)
 
     def _reset_layout(self) -> None:
         """Reset window layout to defaults."""
@@ -331,6 +340,7 @@ class MainWindow(QMainWindow):
         )
 
         set_setting("font_size", "13")
+        self._apply_font_size()
         self.status_bar.showMessage("Layout reset to defaults", 3000)
 
     def _restore_tab_layouts(self) -> None:
@@ -373,13 +383,9 @@ class MainWindow(QMainWindow):
         self.status_bar.showMessage(f"Selected: {connection_name}")
 
     def _on_connect_requested(self, connection_name: str) -> None:
-        """Handle request to connect to a database."""
+        """Handle request to activate a connection (verify credentials)."""
         self._connect(connection_name)
 
-    def _on_disconnect_requested(self, connection_name: str) -> None:
-        """Handle request to disconnect from a database."""
-        self.disconnect(connection_name)
-
     def _on_new_sql_tab(self, connection_name: str) -> None:
         """Create new SQL tab for connection."""
         from .tabs.sql_tab import SQLTab
@@ -605,12 +611,15 @@ class MainWindow(QMainWindow):
             try:
                 result = subprocess.run(
                     ["pipx", "upgrade", "sqlbench"],
-                    capture_output=True, text=True)
+                    capture_output=True, text=True,
+                    stdin=subprocess.DEVNULL, timeout=120)
                 if result.returncode == 0:
                     self._upgrade_result = (True, "SQLBench has been upgraded.\nPlease restart to use the new version.")
                 else:
                     error = result.stderr or result.stdout or "Unknown error"
                     self._upgrade_result = (False, f"Failed to upgrade:\n{error}")
+            except subprocess.TimeoutExpired:
+                self._upgrade_result = (False, "Upgrade timed out. Please upgrade manually:\n\npipx upgrade sqlbench")
             except FileNotFoundError:
                 self._upgrade_result = (False, "pipx not found. Please upgrade manually:\n\npipx upgrade sqlbench")
             except Exception as e:

{sqlbench-0.1.56 → sqlbench-0.1.59}/sqlbench/qt/tabs/sql_tab.py

@@ -44,6 +44,7 @@ from PyQt6.QtWidgets import (
     QMessageBox,
     QHeaderView,
     QAbstractItemView,
+    QAbstractItemDelegate,
     QApplication,
     QFrame,
 )
@@ -498,10 +499,36 @@ class ResultsTable(QTableWidget):
         self.horizontalHeader().sectionDoubleClicked.connect(self._auto_fit_column)
         self.verticalHeader().setDefaultSectionSize(24)
 
+        # Column width tracking for font scaling
+        self._base_widths: dict = {}  # col_index -> base width at scale 1.0
+        self._pk_indices: List[int] = []  # set by SQLTab for tab-to-next-cell
+
         # Context menu
         self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
         self.customContextMenuRequested.connect(self._show_context_menu)
 
+    def closeEditor(self, editor, hint) -> None:
+        """Override to skip PK columns when Tab is pressed during editing."""
+        if hint == QAbstractItemDelegate.EndEditHint.EditNextItem and self._pk_indices:
+            # Tab was pressed — commit and move to next non-PK column
+            super().closeEditor(editor, QAbstractItemDelegate.EndEditHint.NoHint)
+            row = self.currentRow()
+            col = self.currentColumn()
+            next_col = col + 1
+            while next_col < self.columnCount():
+                if next_col not in self._pk_indices:
+                    self.setCurrentCell(row, next_col)
+                    self.editItem(self.item(row, next_col))
+                    return
+                next_col += 1
+            return
+        super().closeEditor(editor, hint)
+
+    def scale_columns(self, scale: float) -> None:
+        """Scale column widths based on font size ratio."""
+        for col, base_w in self._base_widths.items():
+            self.setColumnWidth(col, int(base_w * scale))
+
     def _show_context_menu(self, pos) -> None:
         """Show context menu."""
         menu = QMenu(self)
@@ -623,10 +650,15 @@ class ResultsTable(QTableWidget):
         # Resize columns to content
         self.resizeColumnsToContents()
 
-        # Cap column widths
+        # Cap column widths and store base widths for font scaling
+        font_size = int(get_setting("font_size", "13"))
+        scale = font_size / 13.0
+        self._base_widths = {}
         for i in range(self.columnCount()):
             if self.columnWidth(i) > 300:
                 self.setColumnWidth(i, 300)
+            # Store base width (at scale 1.0) for later rescaling
+            self._base_widths[i] = int(self.columnWidth(i) / scale) if scale else self.columnWidth(i)
 
         self.setSortingEnabled(True)
 
@@ -1133,6 +1165,24 @@ class SQLTab(QWidget):
         """Check if this tab has unsaved cell edits."""
         return bool(self._modified_cells)
 
+    def set_font_size(self, size: int) -> None:
+        """Apply new font size to editor and results."""
+        self.editor.set_font_size(size)
+
+        # Scale results and fields column widths
+        scale = size / 13.0
+        self.results_table.scale_columns(scale)
+
+        # Scale row heights
+        row_height = max(24, int(size * 1.8))
+        self.results_table.verticalHeader().setDefaultSectionSize(row_height)
+        self.fields_table.verticalHeader().setDefaultSectionSize(row_height)
+
+        # Update stats font
+        font = self.stats_text.font()
+        font.setPointSize(size)
+        self.stats_text.setFont(font)
+
     def set_sql(self, sql: str) -> None:
         """Set the SQL text."""
         self.editor.setPlainText(sql)
@@ -2005,6 +2055,7 @@ class SQLTab(QWidget):
         self._edit_schema = None
         self._pk_columns = []
         self._pk_indices = []
+        self.results_table._pk_indices = []
         self._original_values = {}
         self._modified_cells = {}
         self.btn_save_changes.hide()
@@ -2053,6 +2104,7 @@ class SQLTab(QWidget):
         self._edit_schema = schema
         self._pk_columns = pk_cols
         self._pk_indices = pk_indices
+        self.results_table._pk_indices = pk_indices
 
         # Store original values
         for row_idx, row in enumerate(rows):

{sqlbench-0.1.56 → sqlbench-0.1.59}/sqlbench/version.py

@@ -4,7 +4,7 @@ import threading
 import urllib.request
 import json
 
-__version__ = "0.1.56"
+__version__ = "0.1.59"
 
 
 def get_installed_version():