openmetadata-ingestion 1.9.0.0__py3-none-any.whl → 1.10.14.4__py3-none-any.whl

metadata/ingestion/source/database/mariadb/metadata.py

@@ -11,21 +11,44 @@
 """
 MariaDB source module
 """
-from typing import Optional
+import traceback
+from typing import Iterable, Optional
 
 from sqlalchemy.dialects.mysql.base import ischema_names
 from sqlalchemy.dialects.mysql.reflection import MySQLTableDefinitionParser
 
+from metadata.generated.schema.api.data.createStoredProcedure import (
+    CreateStoredProcedureRequest,
+)
+from metadata.generated.schema.entity.data.databaseSchema import DatabaseSchema
+from metadata.generated.schema.entity.data.storedProcedure import StoredProcedureCode
 from metadata.generated.schema.entity.services.connections.database.mariaDBConnection import (
     MariaDBConnection,
 )
+from metadata.generated.schema.entity.services.ingestionPipelines.status import (
+    StackTraceError,
+)
 from metadata.generated.schema.metadataIngestion.workflow import (
     Source as WorkflowSource,
 )
+from metadata.generated.schema.type.basic import EntityName, Markdown
+from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import InvalidSourceException
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.database.common_db_source import CommonDbSourceService
+from metadata.ingestion.source.database.mariadb.models import (
+    ROUTINE_TYPE_MAP,
+    MariaDBStoredProcedure,
+)
+from metadata.ingestion.source.database.mariadb.queries import (
+    MARIADB_GET_FUNCTIONS,
+    MARIADB_GET_STORED_PROCEDURES,
+)
 from metadata.ingestion.source.database.mysql.utils import col_type_map, parse_column
+from metadata.utils import fqn
+from metadata.utils.logger import ingestion_logger
+
+logger = ingestion_logger()
 
 ischema_names.update(col_type_map)
 
@@ -52,3 +75,65 @@ class MariadbSource(CommonDbSourceService):
                 f"Expected MariaDBConnection, but got {connection}"
             )
         return cls(config, metadata)
+
+    def _get_stored_procedures_internal(
+        self, query: str
+    ) -> Iterable[MariaDBStoredProcedure]:
+        results = self.engine.execute(query).all()
+        for row in results:
+            try:
+                yield MariaDBStoredProcedure.model_validate(dict(row._mapping))
+            except Exception as exc:
+                error = f"Error parsing Stored Procedure payload: {exc}"
+                logger.error(error)
+                self.status.failed(
+                    error=StackTraceError(
+                        name=dict(row).get("procedure_name", "UNKNOWN"),
+                        error=error,
+                        stackTrace=traceback.format_exc(),
+                    )
+                )
+
+    def get_stored_procedures(self) -> Iterable[MariaDBStoredProcedure]:
+        """List stored procedures"""
+        if self.source_config.includeStoredProcedures:
+            for query in (MARIADB_GET_STORED_PROCEDURES, MARIADB_GET_FUNCTIONS):
+                yield from self._get_stored_procedures_internal(
+                    query.format(schema_name=self.context.get().database_schema)
+                )
+
+    def yield_stored_procedure(
+        self, stored_procedure
+    ) -> Iterable[Either[CreateStoredProcedureRequest]]:
+        """Prepare the stored procedure payload"""
+        try:
+            stored_procedure_request = CreateStoredProcedureRequest(
+                name=EntityName(stored_procedure.name),
+                description=(
+                    Markdown(stored_procedure.description)
+                    if stored_procedure.description
+                    else None
+                ),
+                storedProcedureCode=StoredProcedureCode(
+                    language=stored_procedure.language, code=stored_procedure.definition
+                ),
+                databaseSchema=fqn.build(
+                    metadata=self.metadata,
+                    entity_type=DatabaseSchema,
+                    service_name=self.context.get().database_service,
+                    database_name=self.context.get().database,
+                    schema_name=self.context.get().database_schema,
+                ),
+                storedProcedureType=ROUTINE_TYPE_MAP[stored_procedure.procedure_type],
+            )
+            yield Either(right=stored_procedure_request)
+            self.register_record_stored_proc_request(stored_procedure_request)
+
+        except Exception as exc:
+            yield Either(
+                left=StackTraceError(
+                    name=stored_procedure.name,
+                    error=f"Error yielding Stored Procedure [{stored_procedure.name}] due to [{exc}]",
+                    stackTrace=traceback.format_exc(),
+                )
+            )

metadata/ingestion/source/database/mariadb/models.py

@@ -0,0 +1,36 @@
+#  Copyright 2025 Collate
+#  Licensed under the Collate Community License, Version 1.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  https://github.com/open-metadata/OpenMetadata/blob/main/ingestion/LICENSE
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""
+MariaDB models
+"""
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from metadata.generated.schema.entity.data.storedProcedure import StoredProcedureType
+
+ROUTINE_TYPE_MAP = {
+    "PROCEDURE": StoredProcedureType.StoredProcedure,
+    "FUNCTION": StoredProcedureType.Function,
+}
+
+
+class MariaDBStoredProcedure(BaseModel):
+    """
+    MariaDB stored procedure list query results
+    """
+
+    name: str = Field(alias="procedure_name")
+    schema_name: str
+    definition: str
+    language: Optional[str]
+    procedure_type: Optional[str]
+    description: Optional[str]

metadata/ingestion/source/database/mariadb/queries.py

@@ -0,0 +1,43 @@
+#  Copyright 2025 Collate
+#  Licensed under the Collate Community License, Version 1.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  https://github.com/open-metadata/OpenMetadata/blob/main/ingestion/LICENSE
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""
+SQL Queries used during MariaDB ingestion
+"""
+
+MARIADB_GET_STORED_PROCEDURES = """
+SELECT
+    ROUTINE_NAME AS procedure_name,
+    ROUTINE_SCHEMA AS schema_name,
+    ROUTINE_DEFINITION AS definition,
+    ROUTINE_TYPE AS procedure_type,
+    ROUTINE_COMMENT AS description,
+    EXTERNAL_LANGUAGE AS language
+FROM
+    information_schema.ROUTINES
+WHERE
+    ROUTINE_SCHEMA = '{schema_name}'
+    AND ROUTINE_TYPE = 'PROCEDURE'
+"""
+
+MARIADB_GET_FUNCTIONS = """
+SELECT
+    ROUTINE_NAME AS procedure_name,
+    ROUTINE_SCHEMA AS schema_name,
+    ROUTINE_DEFINITION AS definition,
+    ROUTINE_TYPE AS procedure_type,
+    ROUTINE_COMMENT AS description,
+    EXTERNAL_LANGUAGE AS language
+FROM
+    information_schema.ROUTINES
+WHERE
+    ROUTINE_SCHEMA = '{schema_name}'
+    AND ROUTINE_TYPE = 'FUNCTION'
+"""

metadata/ingestion/source/database/mssql/lineage.py

@@ -11,13 +11,8 @@
 """
 MSSQL lineage module
 """
-import traceback
 from datetime import datetime
-from typing import Dict, List
 
-from metadata.generated.schema.entity.services.ingestionPipelines.status import (
-    StackTraceError,
-)
 from metadata.ingestion.source.database.lineage_source import LineageSource
 from metadata.ingestion.source.database.mssql.constants import (
     DEFAULT_DATETIME_FORMAT,
@@ -32,13 +27,9 @@ from metadata.ingestion.source.database.mssql.utils import (
     get_sqlalchemy_engine_dateformat,
 )
 from metadata.ingestion.source.database.stored_procedures_mixin import (
-    QueryByProcedure,
     StoredProcedureLineageMixin,
 )
 from metadata.utils.helpers import get_start_and_end
-from metadata.utils.logger import ingestion_logger
-
-logger = ingestion_logger()
 
 
 class MssqlLineageSource(
@@ -74,10 +65,9 @@ class MssqlLineageSource(
             result_limit=self.source_config.resultLimit,
         )
 
-    def get_stored_procedure_queries_dict(self) -> Dict[str, List[QueryByProcedure]]:
+    def get_stored_procedure_sql_statement(self) -> str:
         """
-        Return the dictionary associating stored procedures to the
-        queries they triggered
+        Return the SQL statement to get the stored procedure queries
         """
         start, _ = get_start_and_end(self.source_config.queryLogDuration)
         server_date_format = get_sqlalchemy_engine_dateformat(self.engine)
@@ -88,19 +78,5 @@ class MssqlLineageSource(
         query = MSSQL_GET_STORED_PROCEDURE_QUERIES.format(
             start_date=start,
         )
-        try:
-            queries_dict = self.procedure_queries_dict(
-                query=query,
-            )
-        except Exception as ex:  # pylint: disable=broad-except
-            logger.debug(f"Error runnning query:\n{query}")
-            self.status.failed(
-                StackTraceError(
-                    name="Stored Procedure",
-                    error=f"Error trying to get stored procedure queries: {ex}",
-                    stackTrace=traceback.format_exc(),
-                )
-            )
-            return {}
 
-        return queries_dict
+        return query

metadata/ingestion/source/database/oracle/connection.py

@@ -14,6 +14,7 @@ Source connection handler
 """
 import os
 import sys
+from copy import deepcopy
 from typing import Optional
 from urllib.parse import quote_plus
 
@@ -26,7 +27,9 @@ from metadata.generated.schema.entity.automations.workflow import (
     Workflow as AutomationWorkflow,
 )
 from metadata.generated.schema.entity.services.connections.database.oracleConnection import (
-    OracleConnection,
+    OracleConnection as OracleConnectionConfig,
+)
+from metadata.generated.schema.entity.services.connections.database.oracleConnection import (
     OracleDatabaseSchema,
     OracleServiceName,
     OracleTNSConnection,
@@ -39,12 +42,15 @@ from metadata.ingestion.connections.builders import (
     get_connection_args_common,
     get_connection_options_dict,
 )
+from metadata.ingestion.connections.connection import BaseConnection
+from metadata.ingestion.connections.secrets import connection_with_options_secrets
 from metadata.ingestion.connections.test_connections import test_connection_db_common
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.database.oracle.queries import (
     CHECK_ACCESS_TO_ALL,
-    ORACLE_GET_SCHEMA,
-    ORACLE_GET_STORED_PACKAGES,
+    TEST_MATERIALIZED_VIEWS,
+    TEST_ORACLE_GET_STORED_PACKAGES,
+    TEST_QUERY_HISTORY,
 )
 from metadata.utils.constants import THREE_MIN
 from metadata.utils.logger import ingestion_logger
@@ -55,123 +61,161 @@ LD_LIB_ENV = "LD_LIBRARY_PATH"
 logger = ingestion_logger()
 
 
-def get_connection_url(connection: OracleConnection) -> str:
-    """
-    Build the URL and handle driver version at system level
-    """
-
-    oracledb.version = CX_ORACLE_LIB_VERSION
-    sys.modules["cx_Oracle"] = oracledb
+class OracleConnection(BaseConnection[OracleConnectionConfig, Engine]):
+    def __init__(self, connection: OracleConnectionConfig):
+        super().__init__(connection)
 
-    url = f"{connection.scheme.value}://"
-    if connection.username:
-        url += f"{quote_plus(connection.username)}"
-        if not connection.password:
-            connection.password = SecretStr("")
-        url += f":{quote_plus(connection.password.get_secret_value())}"
-        url += "@"
-
-    url = _handle_connection_type(url=url, connection=connection)
-
-    options = get_connection_options_dict(connection)
-    if options:
-        params = "&".join(
-            f"{key}={quote_plus(value)}" for (key, value) in options.items() if value
+    def _get_client(self) -> Engine:
+        """
+        Create connection
+        """
+        try:
+            if self.service_connection.instantClientDirectory:
+                logger.info(
+                    f"Initializing Oracle thick client at {self.service_connection.instantClientDirectory}"
+                )
+                os.environ[LD_LIB_ENV] = self.service_connection.instantClientDirectory
+                oracledb.init_oracle_client(
+                    lib_dir=self.service_connection.instantClientDirectory
+                )
+        except DatabaseError as err:
+            logger.info(f"Could not initialize Oracle thick client: {err}")
+
+        return create_generic_db_connection(
+            connection=self.service_connection,
+            get_connection_url_fn=self.get_connection_url,
+            get_connection_args_fn=get_connection_args_common,
         )
-        if isinstance(connection.oracleConnectionType, OracleServiceName):
-            url = f"{url}&{params}"
-        else:
-            url = f"{url}?{params}"
-
-    return url
-
-
-def _handle_connection_type(url: str, connection: OracleConnection) -> str:
-    """
-    Depending on the oracle connection type, we need to handle the URL differently
-    """
-
-    if isinstance(connection.oracleConnectionType, OracleTNSConnection):
-        # ref https://stackoverflow.com/questions/14140902/using-oracle-service-names-with-sqlalchemy
-        url += connection.oracleConnectionType.oracleTNSConnection
-        return url
-
-    # If not TNS, we add the hostPort
-    url += connection.hostPort
 
-    if isinstance(connection.oracleConnectionType, OracleDatabaseSchema):
-        url += (
-            f"/{connection.oracleConnectionType.databaseSchema}"
-            if connection.oracleConnectionType.databaseSchema
-            else ""
+    def test_connection(
+        self,
+        metadata: OpenMetadata,
+        automation_workflow: Optional[AutomationWorkflow] = None,
+        timeout_seconds: Optional[int] = THREE_MIN,
+    ) -> TestConnectionResult:
+        """
+        Test connection. This can be executed either as part
+        of a metadata workflow or during an Automation Workflow
+        """
+
+        test_conn_queries = {
+            "CheckAccess": CHECK_ACCESS_TO_ALL,
+            "PackageAccess": TEST_ORACLE_GET_STORED_PACKAGES,
+            "GetMaterializedViews": TEST_MATERIALIZED_VIEWS,
+            "GetQueryHistory": TEST_QUERY_HISTORY,
+        }
+
+        return test_connection_db_common(
+            metadata=metadata,
+            engine=self.client,
+            service_connection=self.service_connection,
+            automation_workflow=automation_workflow,
+            queries=test_conn_queries,
+            timeout_seconds=timeout_seconds,
         )
-        return url
 
-    if isinstance(connection.oracleConnectionType, OracleServiceName):
-        url = f"{url}/?service_name={connection.oracleConnectionType.oracleServiceName}"
-        return url
-
-    raise ValueError(f"Unknown connection type {connection.oracleConnectionType}")
+    def get_connection_dict(self) -> dict:
+        """
+        Return the connection dictionary for this service.
+        """
+        url = self.client.url
+        connection_copy = deepcopy(self.service_connection)
+
+        connection_dict = {
+            "driver": url.drivername,
+            "host": f"{url.host}:{url.port}",  # This is the format expected by data-diff. If we start using this for something else, we need to change it and modify the data-diff code.
+            "user": url.username,
+        }
+
+        # Add password if present in the connection
+        if connection_copy.password:
+            connection_dict["password"] = connection_copy.password.get_secret_value()
+
+        # Add connection type specific information
+        if isinstance(connection_copy.oracleConnectionType, OracleDatabaseSchema):
+            connection_dict[
+                "database"
+            ] = connection_copy.oracleConnectionType.databaseSchema
+        elif isinstance(connection_copy.oracleConnectionType, OracleServiceName):
+            connection_dict[
+                "database"
+            ] = connection_copy.oracleConnectionType.oracleServiceName
+        elif isinstance(connection_copy.oracleConnectionType, OracleTNSConnection):
+            connection_dict[
+                "host"
+            ] = connection_copy.oracleConnectionType.oracleTNSConnection
+
+        # Add connection options if present
+        if connection_copy.connectionOptions and connection_copy.connectionOptions.root:
+            connection_with_options_secrets(lambda: connection_copy)
+            connection_dict.update(connection_copy.connectionOptions.root)
+
+        # Add connection arguments if present
+        if (
+            connection_copy.connectionArguments
+            and connection_copy.connectionArguments.root
+        ):
+            connection_dict.update(get_connection_args_common(connection_copy))
+
+        return connection_dict
+
+    @staticmethod
+    def get_connection_url(connection: OracleConnectionConfig) -> str:
+        """
+        Build the URL and handle driver version at system level
+        """
+
+        oracledb.version = CX_ORACLE_LIB_VERSION
+        sys.modules["cx_Oracle"] = oracledb
+
+        url = f"{connection.scheme.value}://"
+        if connection.username:
+            url += f"{quote_plus(connection.username)}"
+            if not connection.password:
+                connection.password = SecretStr("")
+            url += f":{quote_plus(connection.password.get_secret_value())}"
+            url += "@"
+
+        url = OracleConnection._handle_connection_type(url=url, connection=connection)
+
+        options = get_connection_options_dict(connection)
+        if options:
+            params = "&".join(
+                f"{key}={quote_plus(value)}"
+                for (key, value) in options.items()
+                if value
+            )
+            if isinstance(connection.oracleConnectionType, OracleServiceName):
+                url = f"{url}&{params}"
+            else:
+                url = f"{url}?{params}"
 
+        return url
 
-def get_connection(connection: OracleConnection) -> Engine:
-    """
-    Create connection
-    """
-    try:
-        if connection.instantClientDirectory:
-            logger.info(
-                f"Initializing Oracle thick client at {connection.instantClientDirectory}"
-            )
-            os.environ[LD_LIB_ENV] = connection.instantClientDirectory
-            oracledb.init_oracle_client()
-    except DatabaseError as err:
-        logger.info(f"Could not initialize Oracle thick client: {err}")
-
-    return create_generic_db_connection(
-        connection=connection,
-        get_connection_url_fn=get_connection_url,
-        get_connection_args_fn=get_connection_args_common,
-    )
-
-
-class OraclePackageAccessError(Exception):
-    """
-    Raised when unable to access Oracle stored packages
-    """
-
-
-def test_connection(
-    metadata: OpenMetadata,
-    engine: Engine,
-    service_connection: OracleConnection,
-    automation_workflow: Optional[AutomationWorkflow] = None,
-    timeout_seconds: Optional[int] = THREE_MIN,
-) -> TestConnectionResult:
-    """
-    Test connection. This can be executed either as part
-    of a metadata workflow or during an Automation Workflow
-    """
-
-    def test_oracle_package_access(engine):
-        try:
-            schema_name = engine.execute(ORACLE_GET_SCHEMA).scalar()
-            return ORACLE_GET_STORED_PACKAGES.format(schema=schema_name)
-        except Exception as e:
-            raise OraclePackageAccessError(
-                f"Failed to access Oracle stored packages: {e}"
+    @staticmethod
+    def _handle_connection_type(url: str, connection: OracleConnectionConfig) -> str:
+        """
+        Depending on the oracle connection type, we need to handle the URL differently
+        """
+
+        if isinstance(connection.oracleConnectionType, OracleTNSConnection):
+            # ref https://stackoverflow.com/questions/14140902/using-oracle-service-names-with-sqlalchemy
+            url += connection.oracleConnectionType.oracleTNSConnection
+            return url
+
+        # If not TNS, we add the hostPort
+        url += connection.hostPort
+
+        if isinstance(connection.oracleConnectionType, OracleDatabaseSchema):
+            url += (
+                f"/{connection.oracleConnectionType.databaseSchema}"
+                if connection.oracleConnectionType.databaseSchema
+                else ""
             )
+            return url
+
+        if isinstance(connection.oracleConnectionType, OracleServiceName):
+            url = f"{url}/?service_name={connection.oracleConnectionType.oracleServiceName}"
+            return url
 
-    test_conn_queries = {
-        "CheckAccess": CHECK_ACCESS_TO_ALL,
-        "PackageAccess": test_oracle_package_access(engine),
-    }
-
-    return test_connection_db_common(
-        metadata=metadata,
-        engine=engine,
-        service_connection=service_connection,
-        automation_workflow=automation_workflow,
-        queries=test_conn_queries,
-        timeout_seconds=timeout_seconds,
-    )
+        raise ValueError(f"Unknown connection type {connection.oracleConnectionType}")

metadata/ingestion/source/database/oracle/lineage.py

@@ -30,8 +30,6 @@ workflowConfig:
       jwtToken: "token"
 """
 
-from typing import Dict, List
-
 from metadata.ingestion.source.database.lineage_source import LineageSource
 from metadata.ingestion.source.database.oracle.queries import (
     ORACLE_GET_STORED_PROCEDURE_QUERIES,
@@ -41,7 +39,6 @@ from metadata.ingestion.source.database.oracle.query_parser import (
     OracleQueryParserSource,
 )
 from metadata.ingestion.source.database.stored_procedures_mixin import (
-    QueryByProcedure,
     StoredProcedureLineageMixin,
 )
 from metadata.utils.helpers import get_start_and_end
@@ -63,17 +60,13 @@ class OracleLineageSource(
 
     stored_procedure_query = ORACLE_GET_STORED_PROCEDURE_QUERIES
 
-    def get_stored_procedure_queries_dict(self) -> Dict[str, List[QueryByProcedure]]:
+    def get_stored_procedure_sql_statement(self) -> str:
         """
-        Return the dictionary associating stored procedures to the
-        queries they triggered
+        Return the SQL statement to get the stored procedure queries
         """
         start, _ = get_start_and_end(self.source_config.queryLogDuration)
         query = self.stored_procedure_query.format(
             start_date=start,
         )
-        queries_dict = self.procedure_queries_dict(
-            query=query,
-        )
 
-        return queries_dict
+        return query

metadata/ingestion/source/database/oracle/queries.py

@@ -95,12 +95,7 @@ WHERE
     type = 'PROCEDURE' and owner = '{schema}'
 """
 )
-ORACLE_GET_SCHEMA = """
-    SELECT USERNAME AS SCHEMA_NAME 
-    FROM ALL_USERS 
-    WHERE ROWNUM = 1 
-    ORDER BY USERNAME
-"""
+
 ORACLE_GET_STORED_PACKAGES = textwrap.dedent(
     """
 SELECT
@@ -115,7 +110,49 @@ FROM
 WHERE TYPE IN ('PACKAGE', 'PACKAGE BODY') AND owner = '{schema}'
 """
 )
+
+TEST_ORACLE_GET_STORED_PACKAGES = textwrap.dedent(
+    """
+SELECT
+    OWNER,
+    NAME,
+    LINE,
+    TEXT,
+    'StoredPackage' as procedure_type
+FROM
+    DBA_SOURCE
+WHERE
+    TYPE IN ('PACKAGE', 'PACKAGE BODY')
+    AND owner = (
+        SELECT
+            USERNAME
+        FROM
+            ALL_USERS
+        WHERE
+            ROWNUM = 1
+    )
+"""
+)
+
 CHECK_ACCESS_TO_ALL = "SELECT table_name FROM DBA_TABLES where ROWNUM < 2"
+
+
+TEST_MATERIALIZED_VIEWS = textwrap.dedent(
+    """
+SELECT COUNT(*) as count
+FROM DBA_MVIEWS
+WHERE ROWNUM = 1
+"""
+)
+
+TEST_QUERY_HISTORY = textwrap.dedent(
+    """
+SELECT COUNT(*) as count
+FROM gv$sql
+WHERE ROWNUM = 1
+"""
+)
+
 ORACLE_GET_STORED_PROCEDURE_QUERIES = textwrap.dedent(
     """
 WITH SP_HISTORY AS (SELECT

metadata/ingestion/source/database/oracle/service_spec.py

@@ -1,3 +1,4 @@
+from metadata.ingestion.source.database.oracle.connection import OracleConnection
 from metadata.ingestion.source.database.oracle.lineage import OracleLineageSource
 from metadata.ingestion.source.database.oracle.metadata import OracleSource
 from metadata.ingestion.source.database.oracle.usage import OracleUsageSource
@@ -7,4 +8,5 @@ ServiceSpec = DefaultDatabaseSpec(
     metadata_source_class=OracleSource,
     lineage_source_class=OracleLineageSource,
     usage_source_class=OracleUsageSource,
+    connection_class=OracleConnection,
 )