sqlbench 0.1.4__tar.gz → 0.1.6__tar.gz

{sqlbench-0.1.4 → sqlbench-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbench
-Version: 0.1.4
+Version: 0.1.6
 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,6 +24,7 @@ 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'
@@ -38,6 +39,8 @@ 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.4 → sqlbench-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlbench"
-version = "0.1.4"
+version = "0.1.6"
 description = "A multi-database SQL workbench with support for IBM i, MySQL, and PostgreSQL"
 readme = "README.md"
 license = "MIT"
@@ -36,11 +36,13 @@ 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"]
 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",
 ]

{sqlbench-0.1.4 → sqlbench-0.1.6}/sqlbench/adapters.py

@@ -1,6 +1,32 @@
 """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):
@@ -175,6 +201,109 @@ 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."""
 
@@ -384,6 +513,7 @@ class PostgreSQLAdapter(DBAdapter):
 # Registry of available adapters
 ADAPTERS = {
     'ibmi': IBMiAdapter,
+    'ibmi_db': IBMiDBAdapter,
     'mysql': MySQLAdapter,
     'postgresql': PostgreSQLAdapter,
 }

{sqlbench-0.1.4 → sqlbench-0.1.6}/sqlbench/app.py

@@ -7,6 +7,7 @@ from tkinter import ttk
 
 from sqlbench.database import Database
 from sqlbench.adapters import get_adapter, ADAPTERS
+from sqlbench.version import __version__
 from sqlbench.tabs.sql_tab import SQLTab
 from sqlbench.tabs.spool_tab import SpoolTab
 from sqlbench.dialogs.connection_dialog import ConnectionDialog
@@ -18,7 +19,7 @@ class SQLBenchApp:
         # Set className for proper window manager integration (Linux/X11)
         # This makes the app show as "SQLBench" in window lists and match the .desktop file
         self.root = tk.Tk(className="sqlbench")
-        self.root.title("SQLBench")
+        self.root.title(f"SQLBench v{__version__}")
 
         # Set window icon
         self._set_window_icon()

{sqlbench-0.1.4 → sqlbench-0.1.6}/sqlbench/dialogs/connection_dialog.py

@@ -1,7 +1,9 @@
 """Connection management dialog."""
 
+import os
 import tkinter as tk
 from tkinter import ttk, messagebox
+from pathlib import Path
 import threading
 
 from sqlbench.adapters import get_adapter_choices, get_adapter, get_unavailable_adapters, ADAPTERS
@@ -204,7 +206,7 @@ class ConnectionDialog:
         for conn in self._connections:
             # Show type indicator
             db_type = conn.get("db_type", "ibmi")
-            type_indicator = {"ibmi": "[i]", "mysql": "[M]", "postgresql": "[P]"}.get(db_type, "[?]")
+            type_indicator = {"ibmi": "[i]", "ibmi_db": "[I]", "mysql": "[M]", "postgresql": "[P]"}.get(db_type, "[?]")
             # Mark unavailable connections
             if db_type not in available_types:
                 type_indicator = "[!]"
@@ -430,6 +432,97 @@ 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()]
@@ -440,13 +533,35 @@ class ConnectionDialog:
 
             python = sys.executable
             for db_type in selected:
-                extra = {"ibmi": "ibmi", "mysql": "mysql", "postgresql": "postgresql"}.get(db_type)
+                extra = {"ibmi": "ibmi", "ibmi_db": "ibmi-db", "mysql": "mysql", "postgresql": "postgresql"}.get(db_type)
                 if extra:
-                    log_status(f"Installing sqlbench[{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", f"sqlbench[{extra}]"],
-                            capture_output=True, text=True, timeout=120
+                            [python, "-m", "pip", "install", package],
+                            capture_output=True, text=True, timeout=180, env=env
                         )
                         if result.returncode == 0:
                             log_status(f"  {extra}: OK")

{sqlbench-0.1.4 → sqlbench-0.1.6}/sqlbench/version.py

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