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

sqlalchemy_jdbcapi/dialects/db2.py

@@ -0,0 +1,134 @@
+"""
+IBM DB2 JDBC dialect for SQLAlchemy.
+
+Provides support for IBM DB2 for Linux, Unix, Windows, and z/OS.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any
+
+from sqlalchemy import exc, sql
+from sqlalchemy.engine import Connection, Dialect
+
+from .base import BaseJDBCDialect, JDBCDriverConfig
+
+logger = logging.getLogger(__name__)
+
+# Try to import DB2 dialect if available
+try:
+    from sqlalchemy.dialects.db2.base import DB2Dialect as BaseDB2Dialect
+
+    HAS_DB2_DIALECT = True
+except ImportError:
+    # Fallback to generic dialect
+    BaseDB2Dialect = Dialect  # type: ignore
+    HAS_DB2_DIALECT = False
+    logger.debug("IBM DB2 dialect not available, using generic implementation")
+
+
+class DB2Dialect(BaseJDBCDialect, BaseDB2Dialect):  # type: ignore
+    """
+    IBM DB2 dialect using JDBC driver.
+
+    Supports DB2-specific features including:
+    - Sequences
+    - Identity columns
+    - Generated columns
+    - Temporal tables (DB2 10+)
+    - JSON support (DB2 11+)
+
+    Connection URL format:
+        jdbcapi+db2://user:password@host:50000/database
+    """
+
+    name = "db2"
+    driver = "jdbcapi"
+
+    # DB2 capabilities
+    supports_native_boolean = False  # DB2 < 11.1 doesn't support BOOLEAN
+    supports_sequences = True
+    supports_identity_columns = True
+    supports_native_enum = False
+
+    @classmethod
+    def get_driver_config(cls) -> JDBCDriverConfig:
+        """Get DB2 JDBC driver configuration."""
+        return JDBCDriverConfig(
+            driver_class="com.ibm.db2.jcc.DB2Driver",
+            jdbc_url_template="jdbc:db2://{host}:{port}/{database}",
+            default_port=50000,
+            supports_transactions=True,
+            supports_schemas=True,
+            supports_sequences=True,
+        )
+
+    def initialize(self, connection: Connection) -> None:
+        """Initialize DB2 connection."""
+        if HAS_DB2_DIALECT:
+            super().initialize(connection)
+        # Basic initialization
+        elif not hasattr(self, "_server_version_info"):
+            self._server_version_info = self._get_server_version_info(connection)
+
+        logger.debug("Initialized DB2 JDBC dialect")
+
+    def _get_server_version_info(self, connection: Connection) -> tuple[int, ...]:
+        """
+        Get DB2 server version.
+
+        Returns:
+            Tuple of version numbers (e.g., (11, 5, 8))
+        """
+        try:
+            # Try DB2-specific version query
+            result = connection.execute(
+                sql.text("SELECT SERVICE_LEVEL FROM SYSIBMADM.ENV_INST_INFO")
+            ).scalar()
+
+            if result:
+                # Parse version from string like:
+                # "DB2 v11.5.8.0"
+                match = re.search(r"v(\d+)\.(\d+)\.(\d+)", result)
+                if match:
+                    major = int(match.group(1))
+                    minor = int(match.group(2))
+                    patch = int(match.group(3))
+                    return (major, minor, patch)
+
+        except exc.DBAPIError as e:
+            logger.warning(f"Failed to get DB2 server version: {e}")
+
+            # Fallback: try alternative query
+            try:
+                result = connection.execute(
+                    sql.text("VALUES (SYSPROC.VERSION())")
+                ).scalar()
+
+                if result:
+                    match = re.search(r"(\d+)\.(\d+)\.(\d+)", result)
+                    if match:
+                        return tuple(int(match.group(i)) for i in range(1, 4))
+
+            except exc.DBAPIError:
+                pass
+
+        # Default fallback
+        return (11, 1, 0)
+
+    def do_ping(self, dbapi_connection: Any) -> bool:
+        """Check if DB2 connection is alive."""
+        try:
+            cursor = dbapi_connection.cursor()
+            cursor.execute("SELECT 1 FROM SYSIBM.SYSDUMMY1")
+            cursor.close()
+            return True
+        except Exception as e:
+            logger.debug(f"DB2 ping failed: {e}")
+            return False
+
+
+# Export the dialect
+dialect = DB2Dialect

sqlalchemy_jdbcapi/dialects/mssql.py

@@ -0,0 +1,117 @@
+"""
+Microsoft SQL Server JDBC dialect for SQLAlchemy.
+
+Provides full SQL Server support through JDBC.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any
+
+from sqlalchemy import exc, sql
+from sqlalchemy.dialects.mssql.base import MSDialect
+from sqlalchemy.engine import Connection
+
+from .base import BaseJDBCDialect, JDBCDriverConfig
+
+logger = logging.getLogger(__name__)
+
+
+class MSSQLDialect(BaseJDBCDialect, MSDialect):
+    """
+    Microsoft SQL Server dialect using JDBC driver.
+
+    Supports SQL Server-specific features including:
+    - T-SQL extensions
+    - TOP clause
+    - OUTPUT clause
+    - Common Table Expressions (CTEs)
+    - Window functions
+    - JSON support (SQL Server 2016+)
+
+    Connection URL formats:
+        jdbcapi+mssql://user:password@host:1433/database
+        jdbcapi+sqlserver://user:password@host:1433/database  # Alias
+    """
+
+    name = "mssql"
+    driver = "jdbcapi"
+
+    # SQL Server capabilities
+    supports_native_boolean = False  # SQL Server uses BIT
+    supports_sequences = True  # SQL Server 2012+
+    supports_native_enum = False
+
+    @classmethod
+    def get_driver_config(cls) -> JDBCDriverConfig:
+        """Get SQL Server JDBC driver configuration."""
+        return JDBCDriverConfig(
+            driver_class="com.microsoft.sqlserver.jdbc.SQLServerDriver",
+            jdbc_url_template="jdbc:sqlserver://{host}:{port};databaseName={database}",
+            default_port=1433,
+            supports_transactions=True,
+            supports_schemas=True,
+            supports_sequences=True,
+        )
+
+    def initialize(self, connection: Connection) -> None:
+        """Initialize SQL Server connection."""
+        super().initialize(connection)
+        logger.debug("Initialized SQL Server JDBC dialect")
+
+    def _get_server_version_info(self, connection: Connection) -> tuple[int, ...]:
+        """
+        Get SQL Server version.
+
+        Returns:
+            Tuple of version numbers (e.g., (15, 0, 4236))
+        """
+        try:
+            result = connection.execute(sql.text("SELECT @@VERSION")).scalar()
+
+            if result:
+                # Parse version from string like:
+                # "Microsoft SQL Server 2019 (RTM-CU15) - 15.0.4236.7 ..."
+                match = re.search(r"- (\d+)\.(\d+)\.(\d+)", result)
+                if match:
+                    major = int(match.group(1))
+                    minor = int(match.group(2))
+                    build = int(match.group(3))
+                    return (major, minor, build)
+
+                # Fallback: try to extract major version from name
+                version_names = {
+                    "2022": (16, 0, 0),
+                    "2019": (15, 0, 0),
+                    "2017": (14, 0, 0),
+                    "2016": (13, 0, 0),
+                    "2014": (12, 0, 0),
+                    "2012": (11, 0, 0),
+                }
+
+                for name, version in version_names.items():
+                    if name in result:
+                        return version
+
+        except exc.DBAPIError as e:
+            logger.warning(f"Failed to get SQL Server version: {e}")
+
+        # Default fallback
+        return (13, 0, 0)
+
+    def do_ping(self, dbapi_connection: Any) -> bool:
+        """Check if SQL Server connection is alive."""
+        try:
+            cursor = dbapi_connection.cursor()
+            cursor.execute("SELECT 1")
+            cursor.close()
+            return True
+        except Exception as e:
+            logger.debug(f"SQL Server ping failed: {e}")
+            return False
+
+
+# Export the dialect
+dialect = MSSQLDialect

sqlalchemy_jdbcapi/dialects/mysql.py

@@ -0,0 +1,152 @@
+"""
+MySQL and MariaDB JDBC dialects for SQLAlchemy.
+
+Provides support for MySQL and MariaDB through JDBC.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any
+
+from sqlalchemy import exc, sql
+from sqlalchemy.dialects.mysql.base import MySQLDialect as BaseMySQLDialect
+from sqlalchemy.engine import Connection
+
+from .base import BaseJDBCDialect, JDBCDriverConfig
+
+logger = logging.getLogger(__name__)
+
+
+class MySQLDialect(BaseJDBCDialect, BaseMySQLDialect):
+    """
+    MySQL dialect using JDBC driver.
+
+    Supports MySQL-specific features including:
+    - AUTO_INCREMENT
+    - Full-text indexes
+    - JSON columns (MySQL 5.7+)
+    - Spatial types
+
+    Connection URL format:
+        jdbcapi+mysql://user:password@host:3306/database
+    """
+
+    name = "mysql"
+    driver = "jdbcapi"
+
+    # MySQL capabilities
+    supports_native_boolean = False  # MySQL uses TINYINT(1)
+    supports_native_enum = True
+    supports_sequences = False  # MySQL < 8.0 doesn't support sequences
+
+    @classmethod
+    def get_driver_config(cls) -> JDBCDriverConfig:
+        """Get MySQL JDBC driver configuration."""
+        return JDBCDriverConfig(
+            driver_class="com.mysql.cj.jdbc.Driver",  # MySQL Connector/J 8.0+
+            jdbc_url_template="jdbc:mysql://{host}:{port}/{database}",
+            default_port=3306,
+            supports_transactions=True,
+            supports_schemas=True,
+            supports_sequences=False,
+        )
+
+    def initialize(self, connection: Connection) -> None:
+        """Initialize MySQL connection."""
+        super().initialize(connection)
+        logger.debug("Initialized MySQL JDBC dialect")
+
+    def _get_server_version_info(self, connection: Connection) -> tuple[int, ...]:
+        """
+        Get MySQL server version.
+
+        Returns:
+            Tuple of version numbers (e.g., (8, 0, 32))
+        """
+        try:
+            result = connection.execute(sql.text("SELECT VERSION()")).scalar()
+
+            if result:
+                # Parse version from string like:
+                # "8.0.32" or "5.7.40-log"
+                match = re.search(r"(\d+)\.(\d+)\.(\d+)", result)
+                if match:
+                    major = int(match.group(1))
+                    minor = int(match.group(2))
+                    patch = int(match.group(3))
+                    return (major, minor, patch)
+
+        except exc.DBAPIError as e:
+            logger.warning(f"Failed to get MySQL server version: {e}")
+
+        # Default fallback
+        return (5, 7, 0)
+
+    def do_ping(self, dbapi_connection: Any) -> bool:
+        """Check if MySQL connection is alive."""
+        try:
+            cursor = dbapi_connection.cursor()
+            cursor.execute("SELECT 1")
+            cursor.close()
+            return True
+        except Exception as e:
+            logger.debug(f"MySQL ping failed: {e}")
+            return False
+
+
+class MariaDBDialect(MySQLDialect):
+    """
+    MariaDB dialect using JDBC driver.
+
+    MariaDB is a MySQL fork with additional features.
+    This dialect extends MySQL with MariaDB-specific capabilities.
+
+    Connection URL format:
+        jdbcapi+mariadb://user:password@host:3306/database
+    """
+
+    name = "mariadb"
+
+    @classmethod
+    def get_driver_config(cls) -> JDBCDriverConfig:
+        """Get MariaDB JDBC driver configuration."""
+        return JDBCDriverConfig(
+            driver_class="org.mariadb.jdbc.Driver",
+            jdbc_url_template="jdbc:mariadb://{host}:{port}/{database}",
+            default_port=3306,
+            supports_transactions=True,
+            supports_schemas=True,
+            supports_sequences=True,  # MariaDB 10.3+ supports sequences
+        )
+
+    def _get_server_version_info(self, connection: Connection) -> tuple[int, ...]:
+        """
+        Get MariaDB server version.
+
+        Returns:
+            Tuple of version numbers (e.g., (10, 11, 2))
+        """
+        try:
+            result = connection.execute(sql.text("SELECT VERSION()")).scalar()
+
+            if result:
+                # Parse version from string like:
+                # "10.11.2-MariaDB" or "10.6.12-MariaDB-log"
+                match = re.search(r"(\d+)\.(\d+)\.(\d+)", result)
+                if match:
+                    major = int(match.group(1))
+                    minor = int(match.group(2))
+                    patch = int(match.group(3))
+                    return (major, minor, patch)
+
+        except exc.DBAPIError as e:
+            logger.warning(f"Failed to get MariaDB server version: {e}")
+
+        # Default fallback
+        return (10, 6, 0)
+
+
+# Export dialects
+dialect = MySQLDialect

sqlalchemy_jdbcapi/dialects/oceanbase.py

@@ -0,0 +1,218 @@
+"""
+OceanBase JDBC dialect for SQLAlchemy.
+
+OceanBase is an enterprise distributed relational database with Oracle compatibility mode.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from datetime import datetime
+from typing import Any
+
+from sqlalchemy import TIMESTAMP, TypeDecorator, exc, sql, util
+from sqlalchemy.dialects.oracle.base import OracleDialect
+from sqlalchemy.engine import Connection
+from sqlalchemy.engine.url import URL, make_url
+
+from .base import BaseJDBCDialect, JDBCDriverConfig
+
+logger = logging.getLogger(__name__)
+
+
+class ObTimestamp(TypeDecorator):
+    """
+    Custom timestamp type for OceanBase.
+
+    Handles conversion between Python datetime and OceanBase Timestamp.
+    """
+
+    impl = TIMESTAMP
+    cache_ok = True
+
+    def process_bind_param(self, value: Any, dialect: Any) -> Any:
+        """Convert Python datetime to OceanBase timestamp."""
+        if isinstance(value, datetime):
+            try:
+                # Try to use JPype to create Java Timestamp
+                import jpype
+
+                if jpype.isJVMStarted():
+                    Timestamp = jpype.JClass("java.sql.Timestamp")
+                    return Timestamp.valueOf(
+                        value.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+                    )
+            except Exception as e:
+                logger.debug(f"Failed to create Java Timestamp: {e}")
+                # Fall back to string representation
+                return value
+        return value
+
+    def process_result_value(self, value: Any, dialect: Any) -> datetime | None:
+        """Convert OceanBase timestamp to Python datetime."""
+        if value is not None:
+            if isinstance(value, datetime):
+                return value
+            if isinstance(value, str):
+                # Parse string timestamp
+                try:
+                    from dateutil import parser
+
+                    return parser.parse(value)
+                except Exception as e:
+                    logger.warning(f"Failed to parse timestamp: {e}")
+                    return None
+        return None
+
+
+class OceanBaseDialect(BaseJDBCDialect, OracleDialect):  # type: ignore
+    """
+    OceanBase dialect using JDBC driver (Oracle compatibility mode).
+
+    OceanBase is a distributed database that supports both MySQL and Oracle
+    compatibility modes. This dialect implements Oracle mode.
+
+    Connection URL format:
+        jdbcapi+oceanbase://user@tenant#cluster:password@host:2881/database
+        jdbcapi+oceanbasejdbc://user:password@host:2881/database  # Alias
+
+    Note: OceanBase uses a special user format: username@tenant#cluster
+    """
+
+    name = "oceanbase"
+    driver = "jdbcapi"
+
+    # OceanBase capabilities
+    supports_native_decimal = True
+    supports_sane_rowcount = False
+    supports_sane_multi_rowcount = False
+    supports_unicode_binds = True
+    supports_statement_cache = True
+    supports_sequences = True
+
+    # Custom column specifications
+    colspecs = util.update_copy(
+        OracleDialect.colspecs,  # type: ignore
+        {TIMESTAMP: ObTimestamp},
+    )
+
+    @classmethod
+    def get_driver_config(cls) -> JDBCDriverConfig:
+        """Get OceanBase JDBC driver configuration."""
+        return JDBCDriverConfig(
+            driver_class="com.oceanbase.jdbc.Driver",
+            jdbc_url_template="jdbc:oceanbase://{host}:{port}/{database}",
+            default_port=2881,
+            supports_transactions=True,
+            supports_schemas=True,
+            supports_sequences=True,
+        )
+
+    def create_connect_args(self, url: URL | str) -> tuple[list[Any], dict[str, Any]]:
+        """
+        Create connection arguments for OceanBase.
+
+        Handles special OceanBase user format and connection properties.
+        """
+        if isinstance(url, str):
+            url = make_url(url)
+
+        config = self.get_driver_config()
+
+        # Build JDBC URL
+        jdbc_url = config.format_jdbc_url(
+            host=url.host or "localhost",
+            port=url.port,
+            database=url.database,
+        )
+
+        logger.debug(f"Creating OceanBase connection to: {jdbc_url}")
+
+        # Build connection properties
+        connect_args: dict[str, Any] = {}
+
+        if url.username:
+            connect_args["user"] = url.username
+        if url.password:
+            connect_args["password"] = url.password
+
+        # Add query parameters as connection properties
+        if url.query:
+            connect_args.update(url.query)
+
+        kwargs = {
+            "jclassname": config.driver_class,
+            "url": jdbc_url,
+            "driver_args": connect_args,
+        }
+
+        return ([], kwargs)
+
+    def initialize(self, connection: Connection) -> None:
+        """Initialize OceanBase connection."""
+        super().initialize(connection)
+        logger.debug("Initialized OceanBase JDBC dialect")
+
+    def _get_server_version_info(self, connection: Connection) -> tuple[int, ...]:
+        """
+        Get OceanBase server version.
+
+        Returns:
+            Tuple of version numbers (e.g., (4, 0, 0))
+        """
+        try:
+            ver_sql = sql.text("SELECT BANNER FROM v$version")
+            banner = connection.execute(ver_sql).scalar()
+
+            if banner:
+                # Parse version from string like:
+                # "OceanBase 4.0.0.0 (r10100032022071511-36b8cb0cebc8c2662e8d0c252603c8f2281bb5cc)"
+                match = re.search(r"OceanBase ([\d+\.]+\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 OceanBase server version: {e}")
+
+        # Default fallback
+        return (3, 0, 0)
+
+    @property
+    def _is_oracle_8(self) -> bool:
+        """OceanBase is never Oracle 8."""
+        return False
+
+    def _check_max_identifier_length(self, connection: Connection) -> int | None:
+        """OceanBase uses Oracle-compatible identifier lengths."""
+        return 128
+
+    def do_rollback(self, dbapi_connection: Any) -> None:
+        """
+        Perform rollback on OceanBase connection.
+
+        OceanBase sometimes has issues with rollback, this provides
+        error handling.
+        """
+        try:
+            if dbapi_connection and not dbapi_connection.closed:
+                dbapi_connection.rollback()
+        except Exception as e:
+            logger.warning(f"OceanBase rollback failed: {e}")
+
+    def do_ping(self, dbapi_connection: Any) -> bool:
+        """Check if OceanBase connection is alive."""
+        try:
+            cursor = dbapi_connection.cursor()
+            cursor.execute("SELECT 1 FROM DUAL")
+            cursor.close()
+            return True
+        except Exception as e:
+            logger.debug(f"OceanBase ping failed: {e}")
+            return False
+
+
+# Export the dialect
+dialect = OceanBaseDialect