sqlbench 0.1.51__tar.gz → 0.1.55__tar.gz

{sqlbench-0.1.51 → sqlbench-0.1.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbench
-Version: 0.1.51
+Version: 0.1.55
 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.51 → sqlbench-0.1.55}/sqlbench/adapters.py

@@ -117,7 +117,9 @@ class IBMiAdapter(DBAdapter):
             f"UID={user};"
             f"PWD={password};"
         )
-        return pyodbc.connect(conn_str)
+        conn = pyodbc.connect(conn_str)
+        conn.autocommit = True
+        return conn
 
     def get_version(self, conn):
         try:
@@ -328,7 +330,9 @@ class MySQLAdapter(DBAdapter):
         }
         if port:
             config['port'] = int(port)
-        return mysql.connector.connect(**config)
+        conn = mysql.connector.connect(**config)
+        conn.autocommit = True
+        return conn
 
     def get_version(self, conn):
         try:
@@ -476,13 +480,15 @@ class PostgreSQLAdapter(DBAdapter):
 
     def connect(self, host, user, password, port=None, database=None):
         import psycopg2
-        return psycopg2.connect(
+        conn = psycopg2.connect(
             host=host,
             user=user,
             password=password,
             dbname=database or 'postgres',
             port=port or 5432
         )
+        conn.autocommit = True
+        return conn
 
     def get_version_query(self):
         return "SELECT version()"
@@ -682,3 +688,14 @@ def get_available_adapters():
     Returns dict of {db_type: is_available}.
     """
     return {key: cls.is_available() for key, cls in ADAPTERS.items()}
+
+
+def connect_from_info(adapter, conn_info):
+    """Create a database connection from an adapter and connection info dict."""
+    return adapter.connect(
+        host=conn_info['host'],
+        port=conn_info.get('port'),
+        database=conn_info.get('database'),
+        user=conn_info['user'],
+        password=conn_info['password']
+    )

{sqlbench-0.1.51 → sqlbench-0.1.55}/sqlbench/qt/connection_tree.py

@@ -249,27 +249,31 @@ class ConnectionTreeWidget(QWidget):
 
     def _load_schemas(self, item: QTreeWidgetItem, connection_name: str) -> None:
         """Load schemas and tables for a connection."""
+        from ..adapters import connect_from_info
+
         if connection_name in self._loading_tables:
             return
         self._loading_tables.add(connection_name)
 
-        # Get main window to access connection
+        # Get connection info from main window
         main_window = self.window()
-        if not hasattr(main_window, 'get_connection'):
+        if not hasattr(main_window, 'get_conn_info'):
             self._loading_tables.discard(connection_name)
             return
 
-        connection = main_window.get_connection(connection_name)
-        if not connection:
+        conn_info = main_window.get_conn_info(connection_name)
+        if not conn_info:
             self._loading_tables.discard(connection_name)
             return
 
-        conn_info = self._connections_info.get(connection_name, {})
         adapter = get_adapter(conn_info.get('db_type'))
         if not adapter:
+            self._loading_tables.discard(connection_name)
             return
 
+        connection = None
         try:
+            connection = connect_from_info(adapter, conn_info)
             cursor = connection.cursor()
             cursor.execute(adapter.get_tables_query())
             tables = cursor.fetchall()
@@ -329,6 +333,12 @@ class ConnectionTreeWidget(QWidget):
             error_item = QTreeWidgetItem([f"Error: {str(e)[:50]}"])
             item.addChild(error_item)
             self._loading_tables.discard(connection_name)
+        finally:
+            if connection:
+                try:
+                    connection.close()
+                except Exception:
+                    pass
 
     def _load_tables(self, schema_item: QTreeWidgetItem) -> None:
         """Load tables for a schema.
@@ -340,6 +350,8 @@ class ConnectionTreeWidget(QWidget):
 
     def _load_columns(self, table_item: QTreeWidgetItem) -> None:
         """Load columns for a table."""
+        from ..adapters import connect_from_info
+
         data = table_item.data(0, Qt.ItemDataRole.UserRole)
         connection_name = data.get('connection')
         schema_name = data.get('schema')
@@ -351,21 +363,24 @@ class ConnectionTreeWidget(QWidget):
         self._loading_fields.add(field_key)
 
         main_window = self.window()
-        if not hasattr(main_window, 'get_connection'):
+        if not hasattr(main_window, 'get_conn_info'):
             self._loading_fields.discard(field_key)
             return
 
-        connection = main_window.get_connection(connection_name)
-        if not connection:
+        conn_info = main_window.get_conn_info(connection_name)
+        if not conn_info:
             self._loading_fields.discard(field_key)
             return
 
-        conn_info = self._connections_info.get(connection_name, {})
         adapter = get_adapter(conn_info.get('db_type'))
         if not adapter:
+            self._loading_fields.discard(field_key)
             return
 
+        connection = None
         try:
+            connection = connect_from_info(adapter, conn_info)
+
             # Build table reference for adapter
             table_ref = f"{schema_name}.{table_name}" if schema_name else table_name
 
@@ -412,6 +427,12 @@ class ConnectionTreeWidget(QWidget):
             error_item = QTreeWidgetItem([f"Error: {str(e)[:50]}"])
             table_item.addChild(error_item)
             self._loading_fields.discard(field_key)
+        finally:
+            if connection:
+                try:
+                    connection.close()
+                except Exception:
+                    pass
 
     def _on_filter_changed(self, text: str) -> None:
         """Handle filter text change."""

{sqlbench-0.1.51 → sqlbench-0.1.55}/sqlbench/qt/main_window.py

@@ -43,8 +43,8 @@ class MainWindow(QMainWindow):
         Theme.set_dark(dark_mode)
         Theme.apply(QApplication.instance())
 
-        # Track active connections
-        self._connections: Dict[str, Any] = {}
+        # Track active connections (credentials only, no persistent connection objects)
+        self._conn_infos: Dict[str, Dict] = {}
         self._adapters: Dict[str, Any] = {}
         self._db_types: Dict[str, str] = {}
 
@@ -203,7 +203,7 @@ class MainWindow(QMainWindow):
 
         # Auto-connect last used connection
         last_conn = get_setting("last_connection")
-        if last_conn and last_conn not in self._connections:
+        if last_conn and last_conn not in self._conn_infos:
             conn_info = get_connection(last_conn)
             if conn_info:
                 self._connect(last_conn)
@@ -294,14 +294,6 @@ class MainWindow(QMainWindow):
                         tab._save_changes()
 
         self._save_state()
-
-        # Close all connections
-        for conn in self._connections.values():
-            try:
-                conn.close()
-            except Exception:
-                pass
-
         event.accept()
 
     def _toggle_dark_mode(self) -> None:
@@ -392,15 +384,15 @@ class MainWindow(QMainWindow):
         """Create new SQL tab for connection."""
         from .tabs.sql_tab import SQLTab
 
-        # Get or create connection
-        if connection_name not in self._connections:
+        # Ensure connection is activated
+        if connection_name not in self._conn_infos:
             self._connect(connection_name)
 
-        connection = self._connections.get(connection_name)
-        if connection:
+        conn_info = self._conn_infos.get(connection_name)
+        if conn_info:
             adapter = self._adapters.get(connection_name)
             db_type = self._db_types.get(connection_name, '')
-            tab = SQLTab(connection_name, connection, adapter, db_type, self)
+            tab = SQLTab(connection_name, conn_info, adapter, db_type, self)
             index = self.tab_container.add_tab(tab, f"{connection_name} SQL")
 
             # Set tab icon based on database type
@@ -412,12 +404,13 @@ class MainWindow(QMainWindow):
         """Create new spool tab for IBM i connection."""
         from .tabs.spool_tab import SpoolTab
 
-        if connection_name not in self._connections:
+        if connection_name not in self._conn_infos:
             self._connect(connection_name)
 
-        connection = self._connections.get(connection_name)
-        if connection:
-            tab = SpoolTab(connection_name, connection, self)
+        conn_info = self._conn_infos.get(connection_name)
+        if conn_info:
+            adapter = self._adapters.get(connection_name)
+            tab = SpoolTab(connection_name, conn_info, adapter, self)
             index = self.tab_container.add_tab(tab, f"{connection_name} Spool")
 
             # IBM i spool tab - set icon
@@ -427,14 +420,14 @@ class MainWindow(QMainWindow):
         """Show first 1000 rows of a table."""
         from .tabs.sql_tab import SQLTab
 
-        if connection_name not in self._connections:
+        if connection_name not in self._conn_infos:
             self._connect(connection_name)
 
-        connection = self._connections.get(connection_name)
-        if connection:
+        conn_info = self._conn_infos.get(connection_name)
+        if conn_info:
             adapter = self._adapters.get(connection_name)
             db_type = self._db_types.get(connection_name, '')
-            tab = SQLTab(connection_name, connection, adapter, db_type, self)
+            tab = SQLTab(connection_name, conn_info, adapter, db_type, self)
             index = self.tab_container.add_tab(tab, f"{connection_name} SQL")
 
             # Set tab icon based on database type
@@ -465,9 +458,9 @@ class MainWindow(QMainWindow):
         self._on_edit_connection(None)
 
     def _connect(self, connection_name: str) -> bool:
-        """Establish connection to database."""
+        """Verify connection credentials and activate connection."""
         from ..database import get_connection
-        from ..adapters import get_adapter
+        from ..adapters import get_adapter, connect_from_info
 
         try:
             conn_info = get_connection(connection_name)
@@ -491,15 +484,12 @@ class MainWindow(QMainWindow):
             self.status_bar.showMessage(f"Connecting to {connection_name}...")
             QApplication.processEvents()
 
-            connection = adapter.connect(
-                host=conn_info['host'],
-                port=conn_info.get('port'),
-                database=conn_info.get('database'),
-                user=conn_info['user'],
-                password=conn_info['password']
-            )
+            # Test connection then close immediately
+            test_conn = connect_from_info(adapter, conn_info)
+            test_conn.close()
 
-            self._connections[connection_name] = connection
+            # Store credentials (no persistent connection)
+            self._conn_infos[connection_name] = conn_info
             self._adapters[connection_name] = adapter
             self._db_types[connection_name] = conn_info['db_type']
             self.connection_tree.set_connected(connection_name, True)
@@ -517,17 +507,12 @@ class MainWindow(QMainWindow):
             return False
 
     def disconnect(self, connection_name: str) -> None:
-        """Disconnect from database."""
-        if connection_name in self._connections:
-            try:
-                self._connections[connection_name].close()
-            except Exception:
-                pass
-            del self._connections[connection_name]
-            self._adapters.pop(connection_name, None)
-            self._db_types.pop(connection_name, None)
-            self.connection_tree.set_connected(connection_name, False)
-            self.status_bar.showMessage(f"Disconnected from {connection_name}", 3000)
+        """Deactivate connection."""
+        self._conn_infos.pop(connection_name, None)
+        self._adapters.pop(connection_name, None)
+        self._db_types.pop(connection_name, None)
+        self.connection_tree.set_connected(connection_name, False)
+        self.status_bar.showMessage(f"Disconnected from {connection_name}", 3000)
 
     def _update_tab_names(self, old_name: str) -> None:
         """Update tab names if a connection was renamed."""
@@ -536,11 +521,11 @@ class MainWindow(QMainWindow):
         if conn:
             return
 
-        if old_name not in self._connections:
+        if old_name not in self._conn_infos:
             return
 
         # Find the new name: look for a connection name we don't recognize
-        known_names = set(self._connections.keys())
+        known_names = set(self._conn_infos.keys())
         new_name = None
         for c in get_connections():
             if c['name'] not in known_names:
@@ -550,8 +535,8 @@ class MainWindow(QMainWindow):
         if not new_name or new_name == old_name:
             return
 
-        # Update connections dict
-        self._connections[new_name] = self._connections.pop(old_name)
+        # Update dicts
+        self._conn_infos[new_name] = self._conn_infos.pop(old_name)
         if old_name in self._adapters:
             self._adapters[new_name] = self._adapters.pop(old_name)
         if old_name in self._db_types:
@@ -562,7 +547,7 @@ class MainWindow(QMainWindow):
             tab = self.tab_container.widget(i)
             if hasattr(tab, 'connection_name') and tab.connection_name == old_name:
                 tab.connection_name = new_name
-                tab.connection = self._connections[new_name]
+                tab.conn_info = self._conn_infos[new_name]
                 current_text = self.tab_container.tabText(i)
                 new_text = current_text.replace(old_name, new_name)
                 self.tab_container.setTabText(i, new_text)
@@ -578,13 +563,25 @@ class MainWindow(QMainWindow):
 
     def _check_for_updates(self) -> None:
         """Check for updates in background."""
-        from ..version import check_for_updates
+        from ..version import get_pypi_version, is_newer_version, __version__
+
+        def do_check():
+            try:
+                latest = get_pypi_version()
+                if latest and is_newer_version(latest, __version__):
+                    self._update_version = latest
+            except Exception:
+                pass
 
-        def on_result(has_update, latest_version):
-            if has_update:
-                QTimer.singleShot(0, lambda: self._show_update_dialog(latest_version))
+        def on_done():
+            version = getattr(self, '_update_version', None)
+            if version:
+                self._show_update_dialog(version)
 
-        check_for_updates(on_result)
+        thread = threading.Thread(target=do_check, daemon=True)
+        thread.start()
+        # Poll from main thread until the background check completes
+        QTimer.singleShot(3000, on_done)
 
     def _show_update_dialog(self, latest_version: str) -> None:
         """Show update available dialog."""
@@ -631,6 +628,10 @@ class MainWindow(QMainWindow):
         """Set status bar message."""
         self.status_bar.showMessage(message, timeout)
 
-    def get_connection(self, name: str) -> Optional[Any]:
-        """Get active connection by name."""
-        return self._connections.get(name)
+    def get_conn_info(self, name: str) -> Optional[Dict]:
+        """Get connection info by name."""
+        return self._conn_infos.get(name)
+
+    def get_adapter(self, name: str) -> Optional[Any]:
+        """Get adapter for a connection by name."""
+        return self._adapters.get(name)

{sqlbench-0.1.51 → sqlbench-0.1.55}/sqlbench/qt/tabs/spool_tab.py

@@ -46,15 +46,19 @@ class SpoolWorker(QThread):
     pdf_complete = pyqtSignal(str)  # output_path
     error = pyqtSignal(str)
 
-    def __init__(self, connection: Any, operation: str, **kwargs):
+    def __init__(self, conn_info: dict, adapter: Any, operation: str, **kwargs):
         super().__init__()
-        self.connection = connection
+        self.conn_info = conn_info
+        self.adapter = adapter
+        self.connection = None
         self.operation = operation
         self.kwargs = kwargs
 
     def run(self) -> None:
         """Execute operation in background."""
+        from ...adapters import connect_from_info
         try:
+            self.connection = connect_from_info(self.adapter, self.conn_info)
             if self.operation == "list":
                 self._list_spool_files()
             elif self.operation == "view":
@@ -65,6 +69,12 @@ class SpoolWorker(QThread):
                 self._generate_pdf()
         except Exception as e:
             self.error.emit(str(e))
+        finally:
+            if self.connection:
+                try:
+                    self.connection.close()
+                except Exception:
+                    pass
 
     def _list_spool_files(self) -> None:
         """List spool files for user."""
@@ -247,12 +257,13 @@ class SpoolWorker(QThread):
 class SpoolTab(QWidget):
     """Tab widget for IBM i spool file management."""
 
-    def __init__(self, connection_name: str, connection: Any,
-                 parent: Optional[QWidget] = None):
+    def __init__(self, connection_name: str, conn_info: dict,
+                 adapter: Any, parent: Optional[QWidget] = None):
         super().__init__(parent)
 
         self.connection_name = connection_name
-        self.connection = connection
+        self.conn_info = conn_info
+        self.adapter = adapter
         self._worker: Optional[SpoolWorker] = None
         self._search_matches: List[int] = []
         self._current_match: int = -1
@@ -436,7 +447,8 @@ class SpoolTab(QWidget):
         self.btn_refresh.setEnabled(False)
 
         self._worker = SpoolWorker(
-            self.connection,
+            self.conn_info,
+            self.adapter,
             "list",
             user=user
         )
@@ -480,7 +492,8 @@ class SpoolTab(QWidget):
         self.btn_print.setEnabled(False)
 
         self._worker = SpoolWorker(
-            self.connection,
+            self.conn_info,
+            self.adapter,
             "view",
             file_name=file_name,
             qualified_job=qualified_job,
@@ -534,7 +547,8 @@ class SpoolTab(QWidget):
         self.btn_refresh.setEnabled(False)
 
         self._worker = SpoolWorker(
-            self.connection,
+            self.conn_info,
+            self.adapter,
             "delete",
             files=files_to_delete
         )
@@ -584,7 +598,8 @@ class SpoolTab(QWidget):
         self.viewer_status.setText("Generating PDF...")
 
         self._worker = SpoolWorker(
-            self.connection,
+            self.conn_info,
+            self.adapter,
             "pdf",
             file_name=self._current_spool_info["file_name"],
             qualified_job=self._current_spool_info["qualified_job"],
@@ -713,7 +728,8 @@ class SpoolTab(QWidget):
         self._print_temp_path = temp_path
 
         self._worker = SpoolWorker(
-            self.connection,
+            self.conn_info,
+            self.adapter,
             "pdf",
             file_name=self._current_spool_info["file_name"],
             qualified_job=self._current_spool_info["qualified_job"],

{sqlbench-0.1.51 → sqlbench-0.1.55}/sqlbench/qt/tabs/sql_tab.py

@@ -137,11 +137,11 @@ class QueryWorker(QThread):
     error = pyqtSignal(str)
     row_count = pyqtSignal(int)
 
-    def __init__(self, connection: Any, sql: str, adapter: Any = None,
+    def __init__(self, conn_info: dict, sql: str, adapter: Any = None,
                  limit: int = 1000, offset: int = 0,
                  fetch_all: bool = False, run_count: bool = True):
         super().__init__()
-        self.connection = connection
+        self.conn_info = conn_info
         self.sql = sql
         self.adapter = adapter
         self.limit = limit
@@ -162,8 +162,11 @@ class QueryWorker(QThread):
 
     def run(self) -> None:
         """Execute query in background."""
+        from ...adapters import connect_from_info
+        conn = None
         try:
-            cursor = self.connection.cursor()
+            conn = connect_from_info(self.adapter, self.conn_info)
+            cursor = conn.cursor()
 
             sql_stripped = self.sql.strip()
             while sql_stripped.endswith(';'):
@@ -222,6 +225,12 @@ class QueryWorker(QThread):
         except Exception as e:
             if not self._cancelled:
                 self.error.emit(str(e))
+        finally:
+            if conn:
+                try:
+                    conn.close()
+                except Exception:
+                    pass
 
 
 class ScriptWorker(QThread):
@@ -230,9 +239,10 @@ class ScriptWorker(QThread):
     all_finished = pyqtSignal(list, float)  # results_list, total_time
     error = pyqtSignal(str)
 
-    def __init__(self, connection: Any, statements: List[str]):
+    def __init__(self, conn_info: dict, adapter: Any, statements: List[str]):
         super().__init__()
-        self.connection = connection
+        self.conn_info = conn_info
+        self.adapter = adapter
         self.statements = statements
         self._cancelled = False
 
@@ -242,79 +252,92 @@ class ScriptWorker(QThread):
 
     def run(self) -> None:
         """Execute all statements sequentially."""
-        results = []
-        total_start = time.time()
-
-        for i, stmt in enumerate(self.statements):
-            if self._cancelled:
-                break
+        from ...adapters import connect_from_info
+        conn = None
+        try:
+            conn = connect_from_info(self.adapter, self.conn_info)
+            results = []
+            total_start = time.time()
 
-            stmt_stripped = stmt.strip()
-            if not stmt_stripped:
-                continue
-            while stmt_stripped.endswith(';'):
-                stmt_stripped = stmt_stripped[:-1].strip()
-            if not stmt_stripped:
-                continue
-
-            result = {
-                "stmt": i + 1,
-                "sql": stmt_stripped[:200] + ('...' if len(stmt_stripped) > 200 else ''),
-                "full_sql": stmt_stripped,
-                "status": "",
-                "time": 0.0,
-                "row_count": 0,
-                "success": True,
-                "error": None,
-            }
+            for i, stmt in enumerate(self.statements):
+                if self._cancelled:
+                    break
+
+                stmt_stripped = stmt.strip()
+                if not stmt_stripped:
+                    continue
+                while stmt_stripped.endswith(';'):
+                    stmt_stripped = stmt_stripped[:-1].strip()
+                if not stmt_stripped:
+                    continue
+
+                result = {
+                    "stmt": i + 1,
+                    "sql": stmt_stripped[:200] + ('...' if len(stmt_stripped) > 200 else ''),
+                    "full_sql": stmt_stripped,
+                    "status": "",
+                    "time": 0.0,
+                    "row_count": 0,
+                    "success": True,
+                    "error": None,
+                }
 
-            try:
-                cursor = self.connection.cursor()
-                start = time.time()
-                cursor.execute(stmt_stripped)
-                elapsed = time.time() - start
-
-                if cursor.description:
-                    rows = cursor.fetchall()
-                    result["row_count"] = len(rows)
-                    result["status"] = f"{len(rows)} row(s) returned"
-                else:
-                    rc = cursor.rowcount if cursor.rowcount >= 0 else 0
-                    result["row_count"] = rc
-                    sql_upper = stmt_stripped.upper()
-                    if sql_upper.startswith("INSERT"):
-                        result["status"] = f"{rc} row(s) inserted"
-                    elif sql_upper.startswith("UPDATE"):
-                        result["status"] = f"{rc} row(s) updated"
-                    elif sql_upper.startswith("DELETE"):
-                        result["status"] = f"{rc} row(s) deleted"
+                try:
+                    cursor = conn.cursor()
+                    start = time.time()
+                    cursor.execute(stmt_stripped)
+                    elapsed = time.time() - start
+
+                    if cursor.description:
+                        rows = cursor.fetchall()
+                        result["row_count"] = len(rows)
+                        result["status"] = f"{len(rows)} row(s) returned"
                     else:
-                        result["status"] = f"OK ({rc} row(s) affected)"
+                        rc = cursor.rowcount if cursor.rowcount >= 0 else 0
+                        result["row_count"] = rc
+                        sql_upper = stmt_stripped.upper()
+                        if sql_upper.startswith("INSERT"):
+                            result["status"] = f"{rc} row(s) inserted"
+                        elif sql_upper.startswith("UPDATE"):
+                            result["status"] = f"{rc} row(s) updated"
+                        elif sql_upper.startswith("DELETE"):
+                            result["status"] = f"{rc} row(s) deleted"
+                        else:
+                            result["status"] = f"OK ({rc} row(s) affected)"
+                        try:
+                            conn.commit()
+                        except Exception:
+                            pass
+
+                    result["time"] = elapsed
+                    cursor.close()
+
+                except Exception as e:
+                    result["success"] = False
+                    result["status"] = "ERROR"
+                    result["error"] = str(e)
+                    result["time"] = time.time() - start
                     try:
-                        self.connection.commit()
+                        conn.rollback()
                     except Exception:
                         pass
 
-                result["time"] = elapsed
-                cursor.close()
+                results.append(result)
 
-            except Exception as e:
-                result["success"] = False
-                result["status"] = "ERROR"
-                result["error"] = str(e)
-                result["time"] = time.time() - start
+            total_time = time.time() - total_start
+
+            if not self._cancelled:
+                self.all_finished.emit(results, total_time)
+        except Exception as e:
+            if not self._cancelled:
+                self.error.emit(str(e))
+        finally:
+            if conn:
                 try:
-                    self.connection.rollback()
+                    conn.close()
                 except Exception:
                     pass
 
-            results.append(result)
-
-        total_time = time.time() - total_start
-
-        if not self._cancelled:
-            self.all_finished.emit(results, total_time)
-
 
 class SQLEditor(QPlainTextEdit):
     """SQL code editor with syntax highlighting."""
@@ -611,13 +634,13 @@ class ResultsTable(QTableWidget):
 class SQLTab(QWidget):
     """Tab widget for SQL editing and execution."""
 
-    def __init__(self, connection_name: str, connection: Any,
+    def __init__(self, connection_name: str, conn_info: dict,
                  adapter: Any = None, db_type: str = '',
                  parent: Optional[QWidget] = None):
         super().__init__(parent)
 
         self.connection_name = connection_name
-        self.connection = connection
+        self.conn_info = conn_info
         self.adapter = adapter
         self.db_type = db_type
         self._worker: Optional[QueryWorker] = None
@@ -1141,7 +1164,7 @@ class SQLTab(QWidget):
         self.btn_cancel.setEnabled(True)
         self._set_status(f"Executing {len(statements)} statement(s)...")
 
-        self._script_worker = ScriptWorker(self.connection, statements)
+        self._script_worker = ScriptWorker(self.conn_info, self.adapter, statements)
         self._script_worker.all_finished.connect(self._on_script_finished)
         self._script_worker.error.connect(self._on_query_error)
         self._script_worker.start()
@@ -1272,7 +1295,7 @@ class SQLTab(QWidget):
 
         # Start worker
         self._worker = QueryWorker(
-            self.connection, sql, self.adapter,
+            self.conn_info, sql, self.adapter,
             self._rows_per_page, 0,
             self.chk_show_all.isChecked(), run_count=True
         )
@@ -1476,7 +1499,7 @@ class SQLTab(QWidget):
         self._set_status("Loading page...")
 
         self._worker = QueryWorker(
-            self.connection, self._last_sql, self.adapter,
+            self.conn_info, self._last_sql, self.adapter,
             self._rows_per_page, offset,
             fetch_all=False, run_count=False
         )
@@ -1850,9 +1873,12 @@ class SQLTab(QWidget):
         if not self.adapter or self.db_type != "ibmi":
             return None
 
+        from ...adapters import connect_from_info
+        conn = None
         explain_data = []
         try:
-            explain_cursor = self.connection.cursor()
+            conn = connect_from_info(self.adapter, self.conn_info)
+            explain_cursor = conn.cursor()
             try:
                 explain_cursor.execute("CALL QSYS2.OVERRIDE_QAQQINI(1, '', '')")
             except Exception:
@@ -1861,7 +1887,7 @@ class SQLTab(QWidget):
             tables = self._extract_tables_from_sql(sql)
             for table in tables[:5]:
                 try:
-                    idx_cursor = self.connection.cursor()
+                    idx_cursor = conn.cursor()
                     idx_cursor.execute("""
                         SELECT INDEX_NAME, COLUMN_NAME, INDEX_TYPE, IS_UNIQUE
                         FROM QSYS2.SYSINDEXES I
@@ -1889,6 +1915,12 @@ class SQLTab(QWidget):
             explain_cursor.close()
         except Exception:
             pass
+        finally:
+            if conn:
+                try:
+                    conn.close()
+                except Exception:
+                    pass
 
         return "\n".join(explain_data) if explain_data else None
 
@@ -1990,8 +2022,13 @@ class SQLTab(QWidget):
             return
 
         try:
-            pk_cols = self.adapter.get_primary_key_columns(
-                self.connection, schema, table)
+            from ...adapters import connect_from_info
+            pk_conn = connect_from_info(self.adapter, self.conn_info)
+            try:
+                pk_cols = self.adapter.get_primary_key_columns(
+                    pk_conn, schema, table)
+            finally:
+                pk_conn.close()
         except Exception:
             pk_cols = []
 
@@ -2104,44 +2141,57 @@ class SQLTab(QWidget):
         if msg.exec() != QMessageBox.StandardButton.Yes:
             return
 
+        from ...adapters import connect_from_info
         errors = []
         success_count = 0
         db = _get_db()
+        conn = None
 
-        for row_idx, changes in list(self._modified_cells.items()):
-            original = self._original_values.get(row_idx)
-            if not original:
-                continue
-            try:
-                sql, params = self._generate_update_sql(changes, original)
-                if sql:
-                    cursor = self.connection.cursor()
-                    start_time = time.time()
-                    cursor.execute(sql, params)
-                    self.connection.commit()
-                    duration = time.time() - start_time
-                    cursor.close()
-                    success_count += 1
-
-                    log_sql = self._format_sql_with_params(sql, params)
-                    db.log_query(self.connection_name, log_sql, duration, 1, "success")
-
-                    # Update original values
-                    current = list(original)
-                    for col_idx, val in changes.items():
-                        current[col_idx] = val
-                    self._original_values[row_idx] = tuple(current)
-
-                    # Remove highlight
-                    for c in range(self.results_table.columnCount()):
-                        it = self.results_table.item(row_idx, c)
-                        if it:
-                            it.setBackground(QColor(0, 0, 0, 0))
+        try:
+            conn = connect_from_info(self.adapter, self.conn_info)
 
-            except Exception as e:
-                errors.append(f"Row {row_idx + 1}: {e}")
+            for row_idx, changes in list(self._modified_cells.items()):
+                original = self._original_values.get(row_idx)
+                if not original:
+                    continue
+                try:
+                    sql, params = self._generate_update_sql(changes, original)
+                    if sql:
+                        cursor = conn.cursor()
+                        start_time = time.time()
+                        cursor.execute(sql, params)
+                        conn.commit()
+                        duration = time.time() - start_time
+                        cursor.close()
+                        success_count += 1
+
+                        log_sql = self._format_sql_with_params(sql, params)
+                        db.log_query(self.connection_name, log_sql, duration, 1, "success")
+
+                        # Update original values
+                        current = list(original)
+                        for col_idx, val in changes.items():
+                            current[col_idx] = val
+                        self._original_values[row_idx] = tuple(current)
+
+                        # Remove highlight
+                        for c in range(self.results_table.columnCount()):
+                            it = self.results_table.item(row_idx, c)
+                            if it:
+                                it.setBackground(QColor(0, 0, 0, 0))
+
+                except Exception as e:
+                    errors.append(f"Row {row_idx + 1}: {e}")
+                    try:
+                        conn.rollback()
+                    except Exception:
+                        pass
+        except Exception as e:
+            errors.append(f"Connection error: {e}")
+        finally:
+            if conn:
                 try:
-                    self.connection.rollback()
+                    conn.close()
                 except Exception:
                     pass
 

{sqlbench-0.1.51 → sqlbench-0.1.55}/sqlbench/version.py

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