sqlbench 0.1.7__tar.gz → 0.1.8__tar.gz

{sqlbench-0.1.7 → sqlbench-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbench
-Version: 0.1.7
+Version: 0.1.8
 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
@@ -24,23 +24,18 @@ Classifier: Topic :: Database :: Front-Ends
 Requires-Python: >=3.9
 Requires-Dist: sqlparse>=0.5.0
 Provides-Extra: all
-Requires-Dist: ibm-db>=3.0.0; extra == 'all'
 Requires-Dist: mysql-connector-python>=8.0.0; extra == 'all'
 Requires-Dist: openpyxl>=3.1.0; extra == 'all'
 Requires-Dist: psycopg2-binary>=2.9.0; extra == 'all'
 Requires-Dist: pyodbc>=4.0.0; extra == 'all'
-Requires-Dist: reportlab>=4.0.0; extra == 'all'
 Provides-Extra: dev
 Requires-Dist: black>=23.0.0; extra == 'dev'
 Requires-Dist: pytest>=7.0.0; extra == 'dev'
 Requires-Dist: ruff>=0.1.0; extra == 'dev'
 Provides-Extra: export
 Requires-Dist: openpyxl>=3.1.0; extra == 'export'
-Requires-Dist: reportlab>=4.0.0; extra == 'export'
 Provides-Extra: ibmi
 Requires-Dist: pyodbc>=4.0.0; extra == 'ibmi'
-Provides-Extra: ibmi-db
-Requires-Dist: ibm-db>=3.0.0; extra == 'ibmi-db'
 Provides-Extra: mysql
 Requires-Dist: mysql-connector-python>=8.0.0; extra == 'mysql'
 Provides-Extra: postgresql

{sqlbench-0.1.7 → sqlbench-0.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlbench"
-version = "0.1.7"
+version = "0.1.8"
 description = "A multi-database SQL workbench with support for IBM i, MySQL, and PostgreSQL"
 readme = "README.md"
 license = "MIT"
@@ -36,14 +36,11 @@ dependencies = [
 mysql = ["mysql-connector-python>=8.0.0"]
 postgresql = ["psycopg2-binary>=2.9.0"]
 ibmi = ["pyodbc>=4.0.0"]
-ibmi-db = ["ibm_db>=3.0.0"]
-export = ["reportlab>=4.0.0", "openpyxl>=3.1.0"]
+export = ["openpyxl>=3.1.0"]
 all = [
     "mysql-connector-python>=8.0.0",
     "psycopg2-binary>=2.9.0",
     "pyodbc>=4.0.0",
-    "ibm_db>=3.0.0",
-    "reportlab>=4.0.0",
     "openpyxl>=3.1.0",
 ]
 dev = [

{sqlbench-0.1.7 → sqlbench-0.1.8}/sqlbench/adapters.py

@@ -1,32 +1,6 @@
 """Database adapters for different database types."""
 
-import os
 from abc import ABC, abstractmethod
-from pathlib import Path
-
-
-def _setup_ibm_db_environment():
-    """Set up environment variables for ibm_db if clidriver is installed."""
-    if os.environ.get("IBM_DB_HOME"):
-        return  # Already configured
-
-    # Check common install locations
-    clidriver_paths = [
-        Path.home() / "db2drivers" / "clidriver",
-        Path("/opt/ibm/db2/clidriver"),
-        Path("/opt/clidriver"),
-    ]
-
-    for cli_path in clidriver_paths:
-        if (cli_path / "lib").exists():
-            os.environ["IBM_DB_HOME"] = str(cli_path)
-            lib_path = os.environ.get("LD_LIBRARY_PATH", "")
-            os.environ["LD_LIBRARY_PATH"] = f"{cli_path}/lib:{lib_path}"
-            break
-
-
-# Set up ibm_db environment before any imports
-_setup_ibm_db_environment()
 
 
 class DBAdapter(ABC):
@@ -201,109 +175,6 @@ class IBMiAdapter(DBAdapter):
         """
 
 
-class IBMiDBAdapter(DBAdapter):
-    """Adapter for IBM i (AS/400) via ibm_db (native CLI driver)."""
-
-    db_type = "ibmi_db"
-    display_name = "IBM i (ibm_db)"
-    default_port = 446  # DRDA port
-    requires_database = False
-    supports_spool = True
-    required_module = "ibm_db"
-    install_hint = "pip install sqlbench[ibmi-db]"
-
-    def connect(self, host, user, password, port=None, database=None):
-        import ibm_db_dbi
-
-        # Build connection string for IBM i
-        # DATABASE can be *LOCAL or the RDB name
-        db_name = database if database else "*LOCAL"
-        port_num = port if port else 446
-
-        conn_str = (
-            f"DATABASE={db_name};"
-            f"HOSTNAME={host};"
-            f"PORT={port_num};"
-            f"PROTOCOL=TCPIP;"
-            f"UID={user};"
-            f"PWD={password};"
-        )
-
-        # ibm_db_dbi provides DB-API 2.0 compliant interface
-        return ibm_db_dbi.connect(conn_str, "", "")
-
-    def get_version(self, conn):
-        try:
-            cursor = conn.cursor()
-            cursor.execute("SELECT OS_VERSION, OS_RELEASE FROM SYSIBMADM.ENV_SYS_INFO")
-            row = cursor.fetchone()
-            cursor.close()
-            if row:
-                return f"{row[0]}.{row[1]}"
-        except Exception:
-            pass
-        return None
-
-    def add_pagination(self, sql, limit, offset=0):
-        """IBM i uses OFFSET/FETCH syntax."""
-        sql_stripped = sql.strip()
-        while sql_stripped.endswith(';'):
-            sql_stripped = sql_stripped[:-1].strip()
-
-        if offset > 0:
-            return f"{sql_stripped} OFFSET {offset} ROWS FETCH FIRST {limit} ROWS ONLY"
-        return f"{sql_stripped} FETCH FIRST {limit} ROWS ONLY"
-
-    def get_select_limit_query(self, table_ref, limit):
-        """Get a SELECT query with row limit for IBM i."""
-        return f"SELECT * FROM {table_ref} FETCH FIRST {limit} ROWS ONLY"
-
-    def get_version_query(self):
-        """Get the SQL to retrieve IBM i version."""
-        return "SELECT OS_VERSION || '.' || OS_RELEASE FROM SYSIBMADM.ENV_SYS_INFO"
-
-    def get_columns_query(self, tables):
-        if not tables:
-            return None
-
-        table_conditions = []
-        for table in tables:
-            if '.' in table:
-                schema, tbl = table.split('.', 1)
-                table_conditions.append(
-                    f"(TABLE_SCHEMA = '{schema.upper()}' AND TABLE_NAME = '{tbl.upper()}')"
-                )
-            else:
-                table_conditions.append(f"TABLE_NAME = '{table.upper()}'")
-
-        where_clause = " OR ".join(table_conditions)
-        return f"""
-            SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, DATA_TYPE, LENGTH, NUMERIC_SCALE
-            FROM QSYS2.SYSCOLUMNS
-            WHERE {where_clause}
-            ORDER BY TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION
-        """
-
-    def get_tables_query(self):
-        """Get tables from IBM i - returns schema, table_name, table_type."""
-        return """
-            SELECT TABLE_SCHEMA, TABLE_NAME, TABLE_TYPE
-            FROM QSYS2.SYSTABLES
-            WHERE TABLE_TYPE IN ('T', 'P', 'V')
-            ORDER BY TABLE_SCHEMA, TABLE_NAME
-        """
-
-    def is_numeric_type(self, type_code):
-        """Check if a type_code represents a numeric type for ibm_db."""
-        # ibm_db uses type codes similar to CLI
-        # Check for Python numeric types as fallback
-        from decimal import Decimal
-        if isinstance(type_code, type):
-            return type_code in (int, float, Decimal)
-        # ibm_db type codes for numeric: various integer constants
-        return False
-
-
 class MySQLAdapter(DBAdapter):
     """Adapter for MySQL."""
 
@@ -513,7 +384,6 @@ class PostgreSQLAdapter(DBAdapter):
 # Registry of available adapters
 ADAPTERS = {
     'ibmi': IBMiAdapter,
-    'ibmi_db': IBMiDBAdapter,
     'mysql': MySQLAdapter,
     'postgresql': PostgreSQLAdapter,
 }

{sqlbench-0.1.7 → sqlbench-0.1.8}/sqlbench/app.py

@@ -1037,11 +1037,7 @@ class SQLBenchApp:
                     text=True
                 )
                 if result.returncode == 0:
-                    self.root.after(0, lambda: tk.messagebox.showinfo(
-                        "Upgrade Complete",
-                        "SQLBench has been upgraded.\n\n"
-                        "Please restart the application to use the new version."
-                    ))
+                    self.root.after(0, self._show_restart_dialog)
                 else:
                     error = result.stderr or result.stdout or "Unknown error"
                     self.root.after(0, lambda: tk.messagebox.showerror(
@@ -1068,6 +1064,56 @@ class SQLBenchApp:
         from sqlbench.version import __version__
         tk.messagebox.showinfo("About", f"SQLBench v{__version__}\nMulti-database SQL Workbench")
 
+    def _show_restart_dialog(self, message="SQLBench has been upgraded.\n\nPlease restart the application to use the new version."):
+        """Show a dialog with restart option."""
+        dialog = tk.Toplevel(self.root)
+        dialog.title("Restart Required")
+        dialog.transient(self.root)
+        dialog.grab_set()
+        dialog.resizable(False, False)
+
+        # Message
+        msg_frame = ttk.Frame(dialog, padding=20)
+        msg_frame.pack(fill=tk.BOTH, expand=True)
+        ttk.Label(msg_frame, text=message, wraplength=300).pack()
+
+        # Buttons
+        btn_frame = ttk.Frame(dialog, padding=(20, 0, 20, 20))
+        btn_frame.pack(fill=tk.X)
+        ttk.Button(btn_frame, text="Restart Now", command=lambda: self._restart_app()).pack(side=tk.LEFT, padx=5)
+        ttk.Button(btn_frame, text="Later", command=dialog.destroy).pack(side=tk.LEFT, padx=5)
+
+        # Center on parent
+        dialog.update_idletasks()
+        w = dialog.winfo_width()
+        h = dialog.winfo_height()
+        x = self.root.winfo_x() + (self.root.winfo_width() - w) // 2
+        y = self.root.winfo_y() + (self.root.winfo_height() - h) // 2
+        dialog.geometry(f"+{x}+{y}")
+
+    def _restart_app(self):
+        """Restart the application."""
+        import sys
+        import os
+
+        # Save current state before restart
+        self._save_geometry()
+        self._save_active_tab()
+        self._save_connection_state()
+
+        # Close connections gracefully
+        for name in list(self.connections.keys()):
+            try:
+                self.connections[name]['conn'].close()
+            except Exception:
+                pass
+
+        self.root.destroy()
+
+        # Re-execute the application
+        python = sys.executable
+        os.execv(python, [python] + sys.argv)
+
     def _show_settings(self):
         """Show settings dialog."""
         settings_win = tk.Toplevel(self.root)

{sqlbench-0.1.7 → sqlbench-0.1.8}/sqlbench/dialogs/connection_dialog.py

@@ -206,7 +206,7 @@ class ConnectionDialog:
         for conn in self._connections:
             # Show type indicator
             db_type = conn.get("db_type", "ibmi")
-            type_indicator = {"ibmi": "[i]", "ibmi_db": "[I]", "mysql": "[M]", "postgresql": "[P]"}.get(db_type, "[?]")
+            type_indicator = {"ibmi": "[i]", "mysql": "[M]", "postgresql": "[P]"}.get(db_type, "[?]")
             # Mark unavailable connections
             if db_type not in available_types:
                 type_indicator = "[!]"
@@ -432,97 +432,6 @@ class ConnectionDialog:
             status_text.config(state=tk.DISABLED)
             dialog.update()
 
-        def install_clidriver(log_status):
-            """Download and install IBM Db2 clidriver for ibm_db."""
-            import platform
-            import tarfile
-            import urllib.request
-            from pathlib import Path
-
-            # Determine platform and download URL
-            system = platform.system().lower()
-            machine = platform.machine().lower()
-
-            if system == "linux" and machine in ("x86_64", "amd64"):
-                url = "https://public.dhe.ibm.com/ibmdl/export/pub/software/data/db2/drivers/odbc_cli/linuxx64_odbc_cli.tar.gz"
-            elif system == "linux" and machine in ("aarch64", "arm64"):
-                url = "https://public.dhe.ibm.com/ibmdl/export/pub/software/data/db2/drivers/odbc_cli/linuxarm64_odbc_cli.tar.gz"
-            elif system == "darwin" and machine in ("x86_64", "amd64"):
-                url = "https://public.dhe.ibm.com/ibmdl/export/pub/software/data/db2/drivers/odbc_cli/macos64_odbc_cli.tar.gz"
-            elif system == "darwin" and machine == "arm64":
-                # M1/M2 Mac - use x86_64 version with Rosetta or native if available
-                url = "https://public.dhe.ibm.com/ibmdl/export/pub/software/data/db2/drivers/odbc_cli/macos64_odbc_cli.tar.gz"
-            elif system == "windows":
-                log_status("  Windows: Please download clidriver manually from IBM")
-                return False
-            else:
-                log_status(f"  Unsupported platform: {system}/{machine}")
-                return False
-
-            # Set up paths
-            home = Path.home()
-            driver_dir = home / "db2drivers"
-            clidriver_path = driver_dir / "clidriver"
-            tar_file = driver_dir / "odbc_cli.tar.gz"
-
-            # Check if already installed
-            if (clidriver_path / "lib").exists():
-                log_status("  clidriver already installed")
-                return True
-
-            try:
-                # Create directory
-                driver_dir.mkdir(parents=True, exist_ok=True)
-
-                # Download
-                log_status("  Downloading clidriver (~100MB)...")
-                urllib.request.urlretrieve(url, tar_file)
-
-                # Extract
-                log_status("  Extracting...")
-                with tarfile.open(tar_file, "r:gz") as tar:
-                    tar.extractall(path=driver_dir)
-
-                # Clean up tar file
-                tar_file.unlink()
-
-                # Set environment variable hint
-                log_status("  clidriver installed to ~/db2drivers/clidriver")
-
-                # Update environment for current process
-                import os
-                cli_path = str(clidriver_path)
-                os.environ["IBM_DB_HOME"] = cli_path
-                lib_path = os.environ.get("LD_LIBRARY_PATH", "")
-                os.environ["LD_LIBRARY_PATH"] = f"{cli_path}/lib:{lib_path}"
-
-                # Add to shell config
-                shell_config = home / ".bashrc"
-                if not shell_config.exists():
-                    shell_config = home / ".profile"
-
-                config_lines = [
-                    f'\n# IBM Db2 clidriver (added by SQLBench)',
-                    f'export IBM_DB_HOME=~/db2drivers/clidriver',
-                    f'export LD_LIBRARY_PATH=$IBM_DB_HOME/lib:$LD_LIBRARY_PATH',
-                ]
-
-                # Check if already in config
-                try:
-                    existing = shell_config.read_text() if shell_config.exists() else ""
-                    if "IBM_DB_HOME" not in existing:
-                        with open(shell_config, "a") as f:
-                            f.write("\n".join(config_lines) + "\n")
-                        log_status(f"  Added environment vars to {shell_config.name}")
-                except Exception:
-                    log_status("  Note: Add IBM_DB_HOME to your shell config manually")
-
-                return True
-
-            except Exception as e:
-                log_status(f"  clidriver install failed: {e}")
-                return False
-
         def do_install():
             install_btn.config(state=tk.DISABLED)
             selected = [db_type for db_type, var in check_vars.items() if var.get()]
@@ -533,35 +442,20 @@ class ConnectionDialog:
 
             python = sys.executable
             for db_type in selected:
-                extra = {"ibmi": "ibmi", "ibmi_db": "ibmi-db", "mysql": "mysql", "postgresql": "postgresql"}.get(db_type)
+                extra = {"ibmi": "ibmi", "mysql": "mysql", "postgresql": "postgresql"}.get(db_type)
                 if extra:
-                    # Special handling for ibm_db - need clidriver first
-                    if db_type == "ibmi_db":
-                        log_status("Installing IBM clidriver...")
-                        if not install_clidriver(log_status):
-                            log_status("  Skipping ibm_db (clidriver required)")
-                            continue
-
                     # Map db_type to actual pip package
                     packages = {
                         "ibmi": "pyodbc",
-                        "ibmi_db": "ibm_db",
                         "mysql": "mysql-connector-python",
                         "postgresql": "psycopg2-binary",
                     }
                     package = packages.get(db_type, extra)
                     log_status(f"Installing {package}...")
                     try:
-                        # Set up environment - inherit current env and add IBM_DB_HOME if needed
-                        env = os.environ.copy()
-                        if db_type == "ibmi_db":
-                            cli_path = Path.home() / "db2drivers" / "clidriver"
-                            if cli_path.exists():
-                                env["IBM_DB_HOME"] = str(cli_path)
-
                         result = subprocess.run(
                             [python, "-m", "pip", "install", package],
-                            capture_output=True, text=True, timeout=180, env=env
+                            capture_output=True, text=True, timeout=180
                         )
                         if result.returncode == 0:
                             log_status(f"  {extra}: OK")
@@ -575,9 +469,17 @@ class ConnectionDialog:
 
             log_status("\nDone! Please restart SQLBench to use new drivers.")
             install_btn.config(state=tk.NORMAL)
+            dialog.after(0, lambda: restart_btn.pack(side=tk.LEFT, padx=5))
+
+        def do_restart():
+            dialog.destroy()
+            if self.app:
+                self.app._restart_app()
 
         btn_frame = ttk.Frame(dialog)
         btn_frame.pack(pady=10)
         install_btn = ttk.Button(btn_frame, text="Install Selected", command=lambda: threading.Thread(target=do_install, daemon=True).start())
         install_btn.pack(side=tk.LEFT, padx=5)
+        restart_btn = ttk.Button(btn_frame, text="Restart Now", command=do_restart)
+        # restart_btn is packed after installation completes
         ttk.Button(btn_frame, text="Close", command=dialog.destroy).pack(side=tk.LEFT, padx=5)

{sqlbench-0.1.7 → sqlbench-0.1.8}/sqlbench/version.py

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