fdc-shared-kernel 0.0.179__tar.gz → 0.0.181__tar.gz

{fdc_shared_kernel-0.0.179 → fdc_shared_kernel-0.0.181}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fdc_shared_kernel
-Version: 0.0.179
+Version: 0.0.181
 Summary: Shared library for microservice
 Author-email: Shikhil S <shikhil.s@dbizsolution.com>, Ahammed Akdham N <ahammedakdham.n@dbizsolution.com>
 Classifier: Programming Language :: Python :: 3
@@ -45,6 +45,8 @@ Requires-Dist: redshift_connector==2.1.2
 Requires-Dist: pypika==0.48.9
 Requires-Dist: snowflake-connector-python==3.16.0
 Requires-Dist: PyMySQL==1.1.1
+Requires-Dist: jaydebeapi==1.2.3
+Requires-Dist: JPype1==1.5.0
 
 # FDC Shared Kernel
 

{fdc_shared_kernel-0.0.179 → fdc_shared_kernel-0.0.181}/fdc_shared_kernel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fdc_shared_kernel
-Version: 0.0.179
+Version: 0.0.181
 Summary: Shared library for microservice
 Author-email: Shikhil S <shikhil.s@dbizsolution.com>, Ahammed Akdham N <ahammedakdham.n@dbizsolution.com>
 Classifier: Programming Language :: Python :: 3
@@ -45,6 +45,8 @@ Requires-Dist: redshift_connector==2.1.2
 Requires-Dist: pypika==0.48.9
 Requires-Dist: snowflake-connector-python==3.16.0
 Requires-Dist: PyMySQL==1.1.1
+Requires-Dist: jaydebeapi==1.2.3
+Requires-Dist: JPype1==1.5.0
 
 # FDC Shared Kernel
 

{fdc_shared_kernel-0.0.179 → fdc_shared_kernel-0.0.181}/fdc_shared_kernel.egg-info/SOURCES.txt

@@ -37,14 +37,18 @@ shared_kernel/constants/constants.py
 shared_kernel/data_warehouse_handlers/__init__.py
 shared_kernel/data_warehouse_handlers/databricks_handler.py
 shared_kernel/data_warehouse_handlers/factory.py
+shared_kernel/data_warehouse_handlers/jdbc_driver_registry.py
+shared_kernel/data_warehouse_handlers/jdbc_handler.py
 shared_kernel/data_warehouse_handlers/mssql_handler.py
 shared_kernel/data_warehouse_handlers/mysql_handler.py
+shared_kernel/data_warehouse_handlers/odbc_handler.py
 shared_kernel/data_warehouse_handlers/postgresql_handler.py
 shared_kernel/data_warehouse_handlers/redshift_handler.py
 shared_kernel/data_warehouse_handlers/snowflake_handler.py
 shared_kernel/data_warehouse_handlers/utils.py
 shared_kernel/data_warehouse_handlers/warehouse_handlers_map.py
 shared_kernel/data_warehouse_handlers/connections/databricks_warehouse_connection.py
+shared_kernel/data_warehouse_handlers/connections/jdbc_warehouse_connection.py
 shared_kernel/data_warehouse_handlers/connections/mssql_warehouse_connection.py
 shared_kernel/data_warehouse_handlers/connections/mysql_warehouse_connection.py
 shared_kernel/data_warehouse_handlers/connections/postgresql_warehouse_connection.py
@@ -52,6 +56,7 @@ shared_kernel/data_warehouse_handlers/connections/redshift_warehouse_connection.
 shared_kernel/data_warehouse_handlers/connections/snowflake_warehouse_connection.py
 shared_kernel/data_warehouse_handlers/custom_query_builders/databricks_query.py
 shared_kernel/data_warehouse_handlers/query_executors/databricks_query_executor.py
+shared_kernel/data_warehouse_handlers/query_executors/jdbc_query_executor.py
 shared_kernel/data_warehouse_handlers/query_executors/mssql_query_executor.py
 shared_kernel/data_warehouse_handlers/query_executors/mysql_query_executor.py
 shared_kernel/data_warehouse_handlers/query_executors/postgresql_query_executor.py
@@ -70,6 +75,7 @@ shared_kernel/datatype_mappings/connectors_to_system/__init__.py
 shared_kernel/datatype_mappings/connectors_to_system/csv.py
 shared_kernel/datatype_mappings/connectors_to_system/databricks.py
 shared_kernel/datatype_mappings/connectors_to_system/db2.py
+shared_kernel/datatype_mappings/connectors_to_system/jdbc.py
 shared_kernel/datatype_mappings/connectors_to_system/jira.py
 shared_kernel/datatype_mappings/connectors_to_system/mssql.py
 shared_kernel/datatype_mappings/connectors_to_system/mysql.py

{fdc_shared_kernel-0.0.179 → fdc_shared_kernel-0.0.181}/fdc_shared_kernel.egg-info/requires.txt

@@ -35,3 +35,5 @@ redshift_connector==2.1.2
 pypika==0.48.9
 snowflake-connector-python==3.16.0
 PyMySQL==1.1.1
+jaydebeapi==1.2.3
+JPype1==1.5.0

{fdc_shared_kernel-0.0.179 → fdc_shared_kernel-0.0.181}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fdc_shared_kernel"
-version = "0.0.179"
+version = "0.0.181"
 requires-python = ">=3.7"
 readme = "README_pypi.md"
 description = "Shared library for microservice"

{fdc_shared_kernel-0.0.179 → fdc_shared_kernel-0.0.181}/requirements.txt

@@ -35,3 +35,5 @@ redshift_connector==2.1.2
 pypika==0.48.9
 snowflake-connector-python==3.16.0
 PyMySQL==1.1.1
+jaydebeapi==1.2.3
+JPype1==1.5.0

fdc_shared_kernel-0.0.181/shared_kernel/data_warehouse_handlers/connections/jdbc_warehouse_connection.py

@@ -0,0 +1,183 @@
+import hashlib
+import time
+import threading
+import jaydebeapi
+import jpype
+import os
+from contextlib import contextmanager
+from typing import Dict, Any, Optional
+
+from shared_kernel.dataclasses.warehouse_configs import JDBCConfig
+from shared_kernel.exceptions.http_exceptions import BadRequest
+from shared_kernel.interfaces.warehouse_connection import DataWarehouseConnection
+from shared_kernel.logger import Logger
+from shared_kernel.config import Config
+from shared_kernel.data_warehouse_handlers.jdbc_driver_registry import get_jdbc_driver_config
+
+config = Config()
+logger = Logger(config.get("APP_NAME"))
+
+class JDBCWarehouseConnection(DataWarehouseConnection):
+    """
+    JDBC warehouse connection using jaydebeapi and JPype1.
+    """
+    _jvm_lock = threading.Lock()
+    _jvm_started = False
+
+    def __init__(
+        self,
+        source_config: JDBCConfig,
+        set_default_schema: bool = True,
+    ):
+        if source_config is None:
+            raise ValueError("Missing required parameter: source_config (JDBCConfig)")
+
+        self._jdbc_config = source_config
+        self.set_default_schema = set_default_schema
+        
+        # Get driver config from registry
+        self.driver_info = get_jdbc_driver_config(source_config.jdbc_subtype)
+        
+        # Build or use the JDBC URL depending on connection_method
+        if source_config.connection_method == "url":
+            if not source_config.jdbc_url:
+                raise ValueError("connection_method is 'url' but 'jdbc_url' is not set in JDBCConfig.")
+            self.jdbc_url = source_config.jdbc_url
+        else:
+            # Default: host mode — build URL from template
+            # We pass the entire config __dict__ to handle all fields (host, port, workspace_id, etc.)
+            self.jdbc_url = self.driver_info["url_template"].format(
+                **source_config.__dict__
+            )
+        
+        self._start_jvm_if_needed()
+
+    def _start_jvm_if_needed(self):
+        """Starts the JVM for JPype if not already running."""
+        with self.__class__._jvm_lock:
+            if not jpype.isJVMStarted():
+                jar_path = self.driver_info["jar_path"]
+                if not os.path.exists(jar_path):
+                    logger.error(f"JDBC Driver JAR not found at: {jar_path}")
+                    # Note: We don't raise here yet, as it might be downloaded later or 
+                    # specific to the environment. But for production, it should be there.
+                
+                # Start JVM with the specific JAR in classpath
+                # We add all jars in the drivers directory to be safe
+                drivers_dir = os.path.dirname(jar_path)
+                
+                # Ensure drivers directory exists
+                if not os.path.exists(drivers_dir):
+                    logger.info(f"Creating missing JDBC drivers directory: {drivers_dir}")
+                    os.makedirs(drivers_dir, exist_ok=True)
+                
+                # List jars if directory exists
+                classpath = []
+                if os.path.exists(drivers_dir):
+                    # Add EVERYTHING in the drivers folder to the initial classpath
+                    classpath = [os.path.join(drivers_dir, f) for f in os.listdir(drivers_dir) if f.endswith('.jar')]
+                    logger.info(f"Initial JDBC Classpath: {classpath}")
+
+                try:
+                    # Note: startJVM can only be called ONCE. 
+                    # We load all JARs now to support future "plug-and-play" connections.
+                    jpype.startJVM(jpype.getDefaultJVMPath(), classpath=classpath, convertStrings=True)
+                    logger.info("JVM started for JDBC connections.")
+                except Exception as e:
+                    logger.error(f"Failed to start JVM: {e}")
+
+        # Check if the specific driver JAR is actually present in the drivers folder
+        # We look for a JAR that contains the subtype name (e.g. 'postgres' or 'mssql')
+        jar_path = self.driver_info["jar_path"]
+        if not os.path.exists(jar_path):
+            drivers_dir = os.path.dirname(jar_path)
+            subtype = self._jdbc_config.jdbc_subtype.lower()
+            
+            logger.warning(f"Exact JAR not found at {jar_path}. Searching for '{subtype}' JAR in {drivers_dir}...")
+            
+            # Smart search: find any jar that starts with or contains the subtype name
+            found_jars = [f for f in os.listdir(drivers_dir) if subtype in f.lower() and f.endswith('.jar')]
+            if found_jars:
+                # Use the first one found
+                self.driver_info["jar_path"] = os.path.join(drivers_dir, found_jars[0])
+                logger.info(f"Smart-matched JDBC driver to: {self.driver_info['jar_path']}")
+            else:
+                logger.error(f"No JAR file matching '{subtype}' found in {drivers_dir}")
+                # We don't raise yet, as the class might somehow be in the global classpath
+
+    @contextmanager
+    def get_connection(self, retries: int = 3, delay: int = 5):
+        """Context manager for JDBC database connections with retry mechanism."""
+        last_exception = None
+        cfg = self._jdbc_config
+        driver_class = self.driver_info["driver_class"]
+        jar_path = self.driver_info["jar_path"]
+
+        for attempt in range(retries):
+            conn = None
+            try:
+                logger.info(f"Connecting to JDBC: {self.jdbc_url} (Driver: {driver_class})")
+                
+                # Establish connection
+                conn = jaydebeapi.connect(
+                    jclassname=driver_class,
+                    url=self.jdbc_url,
+                    driver_args=[cfg.username, cfg.password],
+                    jars=jar_path
+                )
+                
+                yield conn
+                return
+
+            except Exception as e:
+                last_exception = e
+                if conn is not None:
+                    try:
+                        conn.close()
+                    except:
+                        pass
+                    conn = None
+
+                logger.warning(f"JDBC connection failed (attempt {attempt + 1}/{retries}): {e}")
+
+                if attempt < retries - 1:
+                    time.sleep(delay)
+                    continue
+                break
+            finally:
+                if conn is not None:
+                    try:
+                        conn.close()
+                    except:
+                        pass
+
+        raise BadRequest(f"Failed to connect to JDBC after {retries} attempts: {last_exception}")
+
+    def close_connection(self):
+        """JDBC connections are closed in the context manager."""
+        pass
+
+    def is_valid_connection(self) -> bool:
+        """Returns True if connection can be established."""
+        try:
+            with self.get_connection():
+                return True
+        except:
+            return False
+
+    def test_connection(self) -> bool:
+        """Verify the connection is reachable."""
+        try:
+            with self.get_connection() as conn:
+                # Use a simple generic query for testing
+                cursor = conn.cursor()
+                # Most DBs support SELECT 1, but we might need variations
+                try:
+                    cursor.execute("SELECT 1")
+                except:
+                    # Fallback for Oracle or others that don't support SELECT 1 without FROM
+                    pass
+                cursor.close()
+                return True
+        except Exception as e:
+            raise ConnectionError(f"JDBC Connection failed: {str(e)}")

fdc_shared_kernel-0.0.181/shared_kernel/data_warehouse_handlers/jdbc_driver_registry.py

@@ -0,0 +1,82 @@
+"""Registry for JDBC driver configurations."""
+
+from typing import Dict, Any
+
+JDBC_DRIVER_REGISTRY: Dict[str, Dict[str, Any]] = {
+    "mssql": {
+        "driver_class": "com.microsoft.sqlserver.jdbc.SQLServerDriver",
+        "url_template": "jdbc:sqlserver://{host}:{port};databaseName={database};encrypt=true;trustServerCertificate=true;loginTimeout=30;",
+        "jar_path": "/app/drivers/mssql.jar",
+        "default_schema": "dbo",
+        "constants_section": "jdbc_mssql",
+    },
+    "postgres": {
+        "driver_class": "org.postgresql.Driver",
+        "url_template": "jdbc:postgresql://{host}:{port}/{database}",
+        "jar_path": "/app/drivers/postgresql.jar",
+        "default_schema": "public",
+        "constants_section": "jdbc_postgres",
+    },
+    "mysql": {
+        "driver_class": "com.mysql.cj.jdbc.Driver",
+        "url_template": "jdbc:mysql://{host}:{port}/{database}?useSSL=false",
+        "jar_path": "/app/drivers/mysql.jar",
+        "default_schema": None,
+        "constants_section": "jdbc_mysql",
+    },
+    "redshift": {
+        "driver_class": "com.amazon.redshift.jdbc42.Driver",
+        "url_template": "jdbc:redshift://{host}:{port}/{database}",
+        "jar_path": "/app/drivers/redshift.jar",
+        "default_schema": "public",
+        "constants_section": "jdbc_redshift",
+    },
+    "fabric_spark": {
+        "driver_class": "com.microsoft.spark.livy.jdbc.LivyDriver",
+        "url_template": (
+            "jdbc:fabricspark://api.fabric.microsoft.com;"
+            "FabricWorkspaceID={workspace_id};"
+            "FabricLakehouseID={lakehouse_id};"
+            "AuthFlow=3;"
+            "AuthTenantID={tenant_id};"
+            "LogLevel=INFO"
+        ),
+        "jar_path": "/app/drivers/fabricspark.jar",
+        "default_schema": "default",
+        "constants_section": "jdbc_fabric_spark",
+    },
+    "fabric_sql": {
+        "driver_class": "com.microsoft.sqlserver.jdbc.SQLServerDriver",
+        "url_template": (
+            "jdbc:sqlserver://{host}:1433;"
+            "database={database};"
+            "encrypt=true;"
+            "trustServerCertificate=false;"
+            "hostNameInCertificate=*.datawarehouse.fabric.microsoft.com;"
+            "loginTimeout=30;"
+            "authentication=ActiveDirectoryServicePrincipal"
+        ),
+        "jar_path": "/app/drivers/mssql.jar",
+        "default_schema": "dbo",
+        "constants_section": "jdbc_mssql",
+    },
+}
+
+def get_jdbc_driver_config(jdbc_subtype: str) -> Dict[str, Any]:
+    """
+    Get JDBC driver configuration for a specific subtype.
+    
+    Args:
+        jdbc_subtype: The database subtype (e.g., 'mssql', 'postgres')
+        
+    Returns:
+        Dict: Driver configuration
+        
+    Raises:
+        ValueError: If subtype is not supported
+    """
+    config = JDBC_DRIVER_REGISTRY.get(jdbc_subtype.lower())
+    if not config:
+        supported = ", ".join(JDBC_DRIVER_REGISTRY.keys())
+        raise ValueError(f"Unsupported JDBC subtype: {jdbc_subtype}. Supported: {supported}")
+    return config

fdc_shared_kernel-0.0.181/shared_kernel/data_warehouse_handlers/jdbc_handler.py

@@ -0,0 +1,118 @@
+from pypika import Query
+
+from shared_kernel.data_warehouse_handlers.connections.jdbc_warehouse_connection import (
+    JDBCWarehouseConnection,
+)
+from shared_kernel.data_warehouse_handlers.query_executors.jdbc_query_executor import (
+    JDBCQueryExecutor,
+)
+from shared_kernel.dataclasses.warehouse_configs import JDBCConfig
+from shared_kernel.interfaces.data_warehouse_handler import WarehouseHandler
+
+
+class JDBCWarehouseHandler(WarehouseHandler):
+    """
+    Handler for JDBC-based data warehouses.
+    """
+
+    def __init__(self, payload: dict = None):
+        super().__init__(payload)
+        self.set_default_schema = self.payload.get("set_default_schema", True)
+
+    def get_config(self) -> JDBCConfig:
+        """
+        Extracts JDBC configuration from payload.
+        Supports two connection methods:
+          - 'host': build URL from host/port/database (default)
+          - 'url':  use a pre-built JDBC URL directly
+        """
+        source_config: JDBCConfig = self.payload.get("source_config")
+        if source_config and isinstance(source_config, JDBCConfig):
+            return source_config
+
+        jdbc_subtype = str(self.payload.get("jdbc_subtype", "mssql")).strip().lower()
+        connection_method = (
+            str(self.payload.get("connection_method", "host")).strip().lower()
+        )
+
+        if connection_method == "url":
+            _required = ("jdbc_url", "user", "password")
+        elif jdbc_subtype == "fabric_spark":
+            _required = ("workspace_id", "lakehouse_id", "tenant_id", "user", "password")
+        elif jdbc_subtype == "fabric_sql":
+            _required = ("host", "database", "tenant_id", "user", "password")
+        else:
+            _required = ("host", "port", "database", "user", "password")
+
+        missing = [f for f in _required if not self.payload.get(f)]
+        if missing:
+            raise ValueError(
+                f"JDBC payload (method='{connection_method}', subtype='{jdbc_subtype}') is missing required fields: {missing}."
+            )
+
+        return JDBCConfig(
+            connection_method=connection_method,
+            jdbc_url=str(self.payload.get("jdbc_url", "")).strip() or None,
+            host=str(self.payload.get("host", "")).strip() or None,
+            port=str(self.payload.get("port", "")).strip() or None,
+            database=str(self.payload.get("database", "")).strip() or None,
+            workspace_id=str(self.payload.get("workspace_id", "")).strip() or None,
+            lakehouse_id=str(self.payload.get("lakehouse_id", "")).strip() or None,
+            tenant_id=str(self.payload.get("tenant_id", "")).strip() or None,
+            username=str(self.payload.get("user")).strip(),
+            password=str(self.payload.get("password")).strip(),
+            jdbc_subtype=jdbc_subtype,
+            schema=(
+                str(self.payload.get("schema")).strip()
+                if self.payload.get("schema")
+                else None
+            ),
+            schema_list=self.payload.get("schema_list"),
+            pagination=self.pagination,
+        )
+
+    def _build_connection(self) -> JDBCWarehouseConnection:
+        """Builds a JDBC connection instance."""
+        return JDBCWarehouseConnection(
+            source_config=self.get_config(),
+            set_default_schema=self.set_default_schema,
+        )
+
+    def get_constants_section(self) -> str:
+        """
+        Returns the constants.ini section to use for SQL queries.
+        Pulls from the driver registry mapping.
+        """
+        from shared_kernel.data_warehouse_handlers.jdbc_driver_registry import get_jdbc_driver_config
+        config_dict = get_jdbc_driver_config(self.get_config().jdbc_subtype)
+        return config_dict["constants_section"]
+
+    def get_executor(self) -> JDBCQueryExecutor:
+        """Returns the JDBC query executor."""
+        connection = self._build_connection()
+        connection.test_connection()
+        return JDBCQueryExecutor(warehouse_connection=connection)
+
+    def get_query_object(self) -> Query:
+        """Returns a generic Query object (dialect-neutral)."""
+        return Query
+
+    def create_records_and_count_query(
+        self,
+        query: str,
+        limit: str,
+        page: str,
+    ) -> tuple[str, str]:
+        """
+        Builds a count query and a paginated query.
+        Using standard SQL syntax which works for most JDBC drivers.
+        """
+        count_query = f"SELECT COUNT(*) FROM ({query}) AS _count"
+
+        if limit:
+            query = f"{query} LIMIT {int(limit)}"
+            if page:
+                offset = (int(page) - 1) * int(limit)
+                query = f"{query} OFFSET {offset}"
+
+        return count_query, query

fdc_shared_kernel-0.0.181/shared_kernel/data_warehouse_handlers/odbc_handler.py

@@ -0,0 +1,13 @@
+from shared_kernel.interfaces.data_warehouse_handler import WarehouseHandler
+
+
+class ODBCWarehouseHandler(WarehouseHandler):
+
+    def get_config(self):
+        pass
+
+    def get_executor(self):
+        pass
+
+    def get_query_object(self):
+        pass

fdc_shared_kernel-0.0.181/shared_kernel/data_warehouse_handlers/query_executors/jdbc_query_executor.py

@@ -0,0 +1,127 @@
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Any, Dict, List, Optional, Tuple
+
+from shared_kernel.config import Config
+from shared_kernel.interfaces.query_executor import DataWarehouseQueryExecutor
+from shared_kernel.interfaces.warehouse_connection import DataWarehouseConnection
+from shared_kernel.logger import Logger
+
+config = Config()
+logger = Logger(config.get("APP_NAME"))
+MAX_QUERY_CONCURRENCY = 5
+
+class JDBCQueryExecutor(DataWarehouseQueryExecutor):
+    """
+    Query executor for JDBC connections.
+    """
+
+    def __init__(self, warehouse_connection: DataWarehouseConnection) -> None:
+        self.warehouse_connection = warehouse_connection
+
+    def execute_query(
+        self,
+        query: str,
+        params: Optional[tuple] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        Execute a single SQL query and return all rows as a list of dicts.
+        """
+        with self.warehouse_connection.get_connection() as conn:
+            cursor = conn.cursor()
+            try:
+                logger.info(f"Executing JDBC query: {query}")
+                start = time.perf_counter()
+
+                if params:
+                    cursor.execute(query, params)
+                else:
+                    cursor.execute(query)
+
+                elapsed = time.perf_counter() - start
+                logger.info(f"JDBC Query executed in {elapsed:.6f}s")
+
+                description = cursor.description
+                if description:
+                    # Normalize column names to lowercase — JDBC drivers return
+                    # column names in varying cases (MySQL → uppercase, PG → lowercase)
+                    columns = [col[0] for col in description]
+                    rows = cursor.fetchall()
+                    return [dict(zip(columns, row)) for row in rows]
+                else:
+                    return []
+
+            except Exception as e:
+                logger.error(f"JDBC Query failed: {query} — {e}", exc_info=True)
+                raise Exception(f"JDBC Query execution failed: {str(e)}") from e
+            finally:
+                cursor.close()
+
+    def execute_queries(
+        self,
+        queries: List[str],
+    ) -> List[List[Dict[str, Any]]]:
+        """
+        Execute multiple SQL queries in parallel and return results in input order.
+        """
+        if not queries:
+            return []
+
+        results: List[Optional[List[Dict[str, Any]]]] = [None] * len(queries)
+
+        with ThreadPoolExecutor(max_workers=MAX_QUERY_CONCURRENCY) as pool:
+            future_to_index = {
+                pool.submit(self.execute_query, query): idx
+                for idx, query in enumerate(queries)
+            }
+
+            for future in as_completed(future_to_index):
+                idx = future_to_index[future]
+                try:
+                    results[idx] = future.result()
+                except Exception as e:
+                    for pending in future_to_index:
+                        if not pending.done():
+                            pending.cancel()
+                    raise Exception(f"Parallel JDBC query failed at index {idx}: {e}") from e
+
+        return results
+
+    def execute_query_with_column_types(
+        self,
+        query: str,
+        params: Optional[tuple] = None,
+    ) -> Tuple[List[Dict[str, Any]], List[Tuple]]:
+        """
+        Execute a query and return both rows and raw cursor description.
+        """
+        with self.warehouse_connection.get_connection() as conn:
+            cursor = conn.cursor()
+            try:
+                logger.info(f"Executing JDBC query with column types: {query}")
+                start = time.perf_counter()
+
+                if params:
+                    cursor.execute(query, params)
+                else:
+                    cursor.execute(query)
+
+                elapsed = time.perf_counter() - start
+                logger.info(f"JDBC Query executed in {elapsed:.6f}s")
+
+                description = cursor.description
+                if description:
+                    # Normalize column names to lowercase
+                    columns = [col[0] for col in description]
+                    raw_rows = cursor.fetchall()
+                    rows = [dict(zip(columns, row)) for row in raw_rows]
+                    # For JDBC, description[i][1] is the java.sql.Types integer constant
+                    return rows, description
+                else:
+                    return [], []
+
+            except Exception as e:
+                logger.error(f"JDBC Query failed: {query} — {e}", exc_info=True)
+                raise Exception(f"JDBC Query execution failed: {str(e)}") from e
+            finally:
+                cursor.close()

{fdc_shared_kernel-0.0.179 → fdc_shared_kernel-0.0.181}/shared_kernel/data_warehouse_handlers/warehouse_handlers_map.py

@@ -6,6 +6,7 @@ from shared_kernel.data_warehouse_handlers.mssql_handler import MSSQLWarehouseHa
 from shared_kernel.data_warehouse_handlers.postgresql_handler import PostgreSQLWarehouseHandler
 from shared_kernel.data_warehouse_handlers.redshift_handler import RedshiftWarehouseHandler
 from shared_kernel.data_warehouse_handlers.snowflake_handler import SnowflakeWarehouseHandler
+from shared_kernel.data_warehouse_handlers.jdbc_handler import JDBCWarehouseHandler
 from shared_kernel.enums.connection_engine import ConnectionEngine
 
 
@@ -18,4 +19,5 @@ warehouse_handlers = {
     ConnectionEngine.MYSQL.value: MySQLWarehouseHandler,
     ConnectionEngine.AZURESQL.value: MSSQLWarehouseHandler,
     ConnectionEngine.DATABRICKS.value: DatabricksWarehouseHandler,
+    ConnectionEngine.JDBC.value: JDBCWarehouseHandler,
 }