sqlalchemy-jdbcapi 2.0.0.post2__py3-none-any.whl

sqlalchemy_jdbcapi/dialects/oracle.py

@@ -0,0 +1,180 @@
+"""
+Oracle JDBC dialect for SQLAlchemy.
+
+Provides full Oracle Database support through JDBC, compatible with SQLAlchemy 2.0+.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any
+
+from sqlalchemy import exc, sql, util
+from sqlalchemy.dialects.oracle.base import OracleDialect
+from sqlalchemy.engine import Connection
+
+from .base import BaseJDBCDialect, JDBCDriverConfig
+
+logger = logging.getLogger(__name__)
+
+
+class OracleDialect(BaseJDBCDialect, OracleDialect):  # type: ignore
+    """
+    Oracle Database dialect using JDBC driver.
+
+    Supports Oracle-specific features including:
+    - Sequences
+    - Synonyms
+    - Database links
+    - Packages
+    - Custom types
+
+    Connection URL formats:
+        jdbcapi+oracle://user:password@host:1521/database
+        jdbcapi+oracle://user:password@host:1521/SID
+        jdbcapi+oraclejdbc://user:password@host:1521/service_name  # Alias
+
+    For TNS connections:
+        jdbcapi+oracle://user:password@tnsname
+    """
+
+    name = "oracle"
+    driver = "jdbcapi"
+
+    # Oracle-specific capabilities
+    supports_sequences = True
+    supports_native_boolean = False  # Oracle < 23c doesn't have native boolean
+    supports_identity_columns = True  # Oracle 12c+
+
+    # Override column specifications for JDBC type handling
+    colspecs = util.update_copy(
+        OracleDialect.colspecs,  # type: ignore
+        {
+            # Add JDBC-specific type mappings here if needed
+        },
+    )
+
+    @classmethod
+    def get_driver_config(cls) -> JDBCDriverConfig:
+        """Get Oracle JDBC driver configuration."""
+        return JDBCDriverConfig(
+            driver_class="oracle.jdbc.OracleDriver",
+            jdbc_url_template="jdbc:oracle:thin:@{host}:{port}/{database}",
+            default_port=1521,
+            supports_transactions=True,
+            supports_schemas=True,
+            supports_sequences=True,
+        )
+
+    def create_connect_args(self, url: Any) -> tuple[list[Any], dict[str, Any]]:
+        """
+        Create connection arguments from SQLAlchemy URL.
+
+        Handles various Oracle connection formats including TNS names.
+        """
+        config = self.get_driver_config()
+
+        # Check if this is a TNS name (no port specified)
+        if url.port is None and url.host and "/" not in url.host:
+            # TNS name format
+            jdbc_url = f"jdbc:oracle:thin:@{url.host}"
+            if url.database:
+                jdbc_url = f"{jdbc_url}/{url.database}"
+        else:
+            # Standard format
+            jdbc_url = config.format_jdbc_url(
+                host=url.host or "localhost",
+                port=url.port,
+                database=url.database,
+                query_params=dict(url.query) if url.query else None,
+            )
+
+        logger.debug(f"Creating Oracle connection to: {jdbc_url}")
+
+        # Build driver arguments
+        driver_args: dict[str, Any] = {}
+
+        if url.username:
+            driver_args["user"] = url.username
+        if url.password:
+            driver_args["password"] = url.password
+
+        # Add query parameters as connection properties
+        if url.query:
+            driver_args.update(url.query)
+
+        kwargs = {
+            "jclassname": config.driver_class,
+            "url": jdbc_url,
+            "driver_args": driver_args if driver_args else None,
+        }
+
+        return ([], kwargs)
+
+    def initialize(self, connection: Connection) -> None:
+        """Initialize Oracle connection."""
+        super().initialize(connection)
+        logger.debug("Initialized Oracle JDBC dialect")
+
+    def _get_server_version_info(self, connection: Connection) -> tuple[int, ...]:
+        """
+        Get Oracle server version.
+
+        Returns:
+            Tuple of version numbers (e.g., (19, 3, 0))
+        """
+        try:
+            banner = connection.execute(
+                sql.text("SELECT BANNER FROM v$version")
+            ).scalar()
+
+            if banner:
+                # Parse version from string like:
+                # "Oracle Database 19c Enterprise Edition Release 19.0.0.0.0 - Production"
+                match = re.search(r"Release ([\d\.]+)", banner)
+                if match:
+                    version_str = match.group(1)
+                    parts = version_str.split(".")
+                    return tuple(int(p) for p in parts[:3])
+
+        except exc.DBAPIError as e:
+            logger.warning(f"Failed to get Oracle server version: {e}")
+
+        # Default fallback
+        return (11, 0, 0)
+
+    @property
+    def _is_oracle_8(self) -> bool:
+        """Check if connected to Oracle 8 (legacy support)."""
+        return getattr(self, "_server_version_info", (11, 0, 0))[0] < 9
+
+    def _check_max_identifier_length(self, connection: Connection) -> int | None:
+        """
+        Get maximum identifier length for this Oracle version.
+
+        Oracle 12.2+ supports 128 characters, earlier versions support 30.
+        """
+        version = getattr(self, "_server_version_info", (11, 0, 0))
+        if version >= (12, 2):
+            return 128
+        return 30
+
+    def do_ping(self, dbapi_connection: Any) -> bool:
+        """
+        Check if Oracle connection is alive.
+
+        Uses Oracle's dual table for efficiency.
+        """
+        try:
+            cursor = dbapi_connection.cursor()
+            cursor.execute("SELECT 1 FROM DUAL")
+            cursor.close()
+            return True
+        except Exception as e:
+            logger.debug(f"Oracle ping failed: {e}")
+            return False
+
+
+# Export the dialect
+dialect = OracleDialect

sqlalchemy_jdbcapi/dialects/postgresql.py

@@ -0,0 +1,110 @@
+"""
+PostgreSQL JDBC dialect for SQLAlchemy.
+
+Provides full PostgreSQL support through JDBC, compatible with SQLAlchemy 2.0+.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any
+
+from sqlalchemy import sql
+from sqlalchemy.dialects.postgresql.base import PGDialect
+from sqlalchemy.engine import Connection
+
+from .base import BaseJDBCDialect, JDBCDriverConfig
+
+logger = logging.getLogger(__name__)
+
+
+class PostgreSQLDialect(BaseJDBCDialect, PGDialect):
+    """
+    PostgreSQL dialect using JDBC driver.
+
+    Supports all PostgreSQL-specific features including:
+    - Arrays
+    - JSONB
+    - UUID
+    - Full-text search
+    - Custom types
+
+    Connection URL format:
+        jdbcapi+postgresql://user:password@host:5432/database
+        jdbcapi+pgjdbc://user:password@host:5432/database  # Alias
+    """
+
+    name = "postgresql"
+    driver = "jdbcapi"
+
+    # PostgreSQL-specific capabilities
+    supports_native_enum = True
+    supports_sequences = True
+    supports_native_boolean = True
+    supports_smallserial = True
+
+    # Column specifications inherited from PGDialect
+    # Can be extended in the future for JDBC-specific type mappings if needed
+
+    @classmethod
+    def get_driver_config(cls) -> JDBCDriverConfig:
+        """Get PostgreSQL JDBC driver configuration."""
+        return JDBCDriverConfig(
+            driver_class="org.postgresql.Driver",
+            jdbc_url_template="jdbc:postgresql://{host}:{port}/{database}",
+            default_port=5432,
+            supports_transactions=True,
+            supports_schemas=True,
+            supports_sequences=True,
+        )
+
+    def initialize(self, connection: Connection) -> None:
+        """Initialize PostgreSQL connection."""
+        super().initialize(connection)
+
+        # Set up PostgreSQL-specific settings
+        logger.debug("Initialized PostgreSQL JDBC dialect")
+
+    def _get_server_version_info(self, connection: Connection) -> tuple[int, ...]:
+        """
+        Get PostgreSQL server version.
+
+        Returns:
+            Tuple of version numbers (e.g., (14, 5, 0))
+        """
+        try:
+            result = connection.execute(sql.text("SELECT version()")).scalar()
+            if result:
+                # Parse version from string like:
+                # "PostgreSQL 14.5 on x86_64-pc-linux-gnu..."
+                match = re.search(r"PostgreSQL (\d+)\.(\d+)(?:\.(\d+))?", result)
+                if match:
+                    major = int(match.group(1))
+                    minor = int(match.group(2))
+                    patch = int(match.group(3)) if match.group(3) else 0
+                    return (major, minor, patch)
+        except Exception as e:
+            logger.warning(f"Failed to get server version: {e}")
+
+        # Default fallback
+        return (9, 0, 0)
+
+    def do_ping(self, dbapi_connection: Any) -> bool:
+        """
+        Check if PostgreSQL connection is alive.
+
+        Uses a simple SELECT query for efficiency.
+        """
+        try:
+            cursor = dbapi_connection.cursor()
+            cursor.execute("SELECT 1")
+            cursor.close()
+            return True
+        except Exception as e:
+            logger.debug(f"PostgreSQL ping failed: {e}")
+            return False
+
+
+# Export the dialect
+dialect = PostgreSQLDialect

sqlalchemy_jdbcapi/dialects/sqlite.py

@@ -0,0 +1,141 @@
+"""
+SQLite JDBC dialect for SQLAlchemy.
+
+Provides SQLite support through JDBC (mainly for testing or Java interop).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from sqlalchemy import exc, sql
+from sqlalchemy.dialects.sqlite.base import SQLiteDialect as BaseSQLiteDialect
+from sqlalchemy.engine import Connection
+
+from .base import BaseJDBCDialect, JDBCDriverConfig
+
+logger = logging.getLogger(__name__)
+
+
+class SQLiteDialect(BaseJDBCDialect, BaseSQLiteDialect):
+    """
+    SQLite dialect using JDBC driver.
+
+    Note: For production use, the native sqlite3 dialect is recommended.
+    This JDBC dialect is primarily useful for:
+    - Testing JDBC infrastructure
+    - Java application integration
+    - Environments where native sqlite3 is not available
+
+    Connection URL format:
+        jdbcapi+sqlite:///path/to/database.db
+        jdbcapi+sqlite:///:memory:  # In-memory database
+    """
+
+    name = "sqlite"
+    driver = "jdbcapi"
+
+    # SQLite capabilities
+    supports_native_boolean = False
+    supports_sequences = False
+    supports_native_enum = False
+    supports_native_decimal = False
+
+    @classmethod
+    def import_dbapi(cls) -> Any:
+        """
+        Import JDBC module.
+
+        SQLAlchemy's SQLite dialect expects sqlite_version_info attribute,
+        so we add it as a wrapper.
+        """
+        from sqlalchemy_jdbcapi import jdbc
+
+        # Add sqlite_version_info if not present (required by SQLAlchemy's SQLite dialect)
+        if not hasattr(jdbc, "sqlite_version_info"):
+            # Use a reasonable default version
+            jdbc.sqlite_version_info = (3, 40, 0)
+
+        return jdbc
+
+    @classmethod
+    def get_driver_config(cls) -> JDBCDriverConfig:
+        """Get SQLite JDBC driver configuration."""
+        return JDBCDriverConfig(
+            driver_class="org.sqlite.JDBC",
+            jdbc_url_template="jdbc:sqlite:{database}",
+            default_port=0,  # Not applicable for SQLite
+            supports_transactions=True,
+            supports_schemas=False,  # SQLite has limited schema support
+            supports_sequences=False,
+        )
+
+    def create_connect_args(self, url: Any) -> tuple[list[Any], dict[str, Any]]:
+        """
+        Create connection arguments for SQLite.
+
+        Handles file paths and in-memory databases.
+        """
+        config = self.get_driver_config()
+
+        # Build JDBC URL
+        if url.database:
+            if url.database == ":memory:":
+                jdbc_url = "jdbc:sqlite::memory:"
+            else:
+                jdbc_url = f"jdbc:sqlite:{url.database}"
+        else:
+            # Default to in-memory
+            jdbc_url = "jdbc:sqlite::memory:"
+
+        logger.debug(f"Creating SQLite connection to: {jdbc_url}")
+
+        kwargs = {
+            "jclassname": config.driver_class,
+            "url": jdbc_url,
+            "driver_args": None,
+        }
+
+        return ([], kwargs)
+
+    def initialize(self, connection: Connection) -> None:
+        """Initialize SQLite connection."""
+        super().initialize(connection)
+        logger.debug("Initialized SQLite JDBC dialect")
+
+    def _get_server_version_info(self, connection: Connection) -> tuple[int, ...]:
+        """
+        Get SQLite version.
+
+        Returns:
+            Tuple of version numbers (e.g., (3, 40, 1))
+        """
+        try:
+            result = connection.execute(sql.text("SELECT sqlite_version()")).scalar()
+
+            if result:
+                # Parse version from string like: "3.40.1"
+                parts = result.split(".")
+                return tuple(int(p) for p in parts[:3])
+
+        except exc.DBAPIError as e:
+            logger.warning(f"Failed to get SQLite version: {e}")
+
+        # Default fallback
+        return (3, 30, 0)
+
+    def do_ping(self, dbapi_connection: Any) -> bool:
+        """Check if SQLite connection is alive."""
+        try:
+            cursor = dbapi_connection.cursor()
+            cursor.execute("SELECT 1")
+            cursor.close()
+            return True
+        except Exception as e:
+            logger.debug(f"SQLite ping failed: {e}")
+            return False
+
+
+# Export the dialect
+dialect = SQLiteDialect

sqlalchemy_jdbcapi/jdbc/__init__.py

@@ -0,0 +1,98 @@
+"""
+JDBC Bridge Layer for SQLAlchemy.
+
+This module provides a Python DB-API 2.0 compliant interface to JDBC drivers
+using JPype for JVM interaction. This replaces the unmaintained JayDeBeApi library
+with a modern, type-safe, and feature-rich implementation.
+"""
+
+from __future__ import annotations
+
+from .connection import Connection, connect
+from .cursor import Cursor
+from .driver_manager import (
+    RECOMMENDED_JDBC_DRIVERS,
+    JDBCDriver,
+    clear_driver_cache,
+    download_driver,
+    get_driver_cache_dir,
+    get_driver_path,
+    list_cached_drivers,
+)
+from .exceptions import (
+    DatabaseError,
+    DataError,
+    Error,
+    IntegrityError,
+    InterfaceError,
+    InternalError,
+    NotSupportedError,
+    OperationalError,
+    ProgrammingError,
+    Warning,
+)
+from .jvm import get_classpath, is_jvm_started, shutdown_jvm, start_jvm
+from .types import (
+    BINARY,
+    DATETIME,
+    NUMBER,
+    ROWID,
+    STRING,
+    Binary,
+    Date,
+    DateFromTicks,
+    Time,
+    TimeFromTicks,
+    Timestamp,
+    TimestampFromTicks,
+)
+
+__all__ = [
+    # Core functions
+    "connect",
+    # JVM management
+    "start_jvm",
+    "is_jvm_started",
+    "shutdown_jvm",
+    "get_classpath",
+    # Driver management
+    "JDBCDriver",
+    "RECOMMENDED_JDBC_DRIVERS",
+    "download_driver",
+    "get_driver_path",
+    "get_driver_cache_dir",
+    "list_cached_drivers",
+    "clear_driver_cache",
+    # Classes
+    "Connection",
+    "Cursor",
+    # Exceptions
+    "Error",
+    "Warning",
+    "InterfaceError",
+    "DatabaseError",
+    "InternalError",
+    "OperationalError",
+    "ProgrammingError",
+    "IntegrityError",
+    "DataError",
+    "NotSupportedError",
+    # Types
+    "Date",
+    "Time",
+    "Timestamp",
+    "DateFromTicks",
+    "TimeFromTicks",
+    "TimestampFromTicks",
+    "Binary",
+    "STRING",
+    "BINARY",
+    "NUMBER",
+    "DATETIME",
+    "ROWID",
+]
+
+# DB-API 2.0 module attributes
+apilevel = "2.0"
+threadsafety = 1  # Threads may share the module, but not connections
+paramstyle = "qmark"  # Question mark style, e.g. ...WHERE name=?