openmetadata-ingestion 1.7.5.3__py3-none-any.whl → 1.8.1.0__py3-none-any.whl

metadata/ingestion/connections/query_logger.py

@@ -0,0 +1,115 @@
+#  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.
+#  pylint: disable=W0613
+
+"""
+Query tracking implementation using SQLAlchemy event listeners
+"""
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional, Tuple, Union
+
+from pydantic import BaseModel, ConfigDict
+from sqlalchemy.event import listen
+from sqlalchemy.sql.elements import TextClause
+
+from metadata.utils.logger import ingestion_logger
+
+logger = ingestion_logger()
+
+
+class QueryInfo(BaseModel):
+    """Class to store information about a query execution"""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    statement: Union[str, TextClause]
+    parameters: Optional[Union[Dict[str, Any], Tuple[Any, ...]]]
+    start_time: datetime
+    end_time: Optional[datetime] = None
+    duration_ms: Optional[float] = None
+    error: Optional[Exception] = None
+
+
+class QueryLogger:
+    """Class to track SQL query execution using SQLAlchemy event listeners"""
+
+    def __init__(self):
+        self._current_query: Optional[QueryInfo] = None
+
+    def before_cursor_execute(
+        self,
+        conn: Any,
+        cursor: Any,
+        statement: Union[str, TextClause],
+        parameters: Optional[Dict[str, Any]],
+        context: Any,
+        executemany: bool,
+    ) -> Tuple[Union[str, TextClause], Optional[Dict[str, Any]]]:
+        """Event listener for before cursor execute"""
+        self._current_query = QueryInfo(
+            statement=statement,
+            parameters=parameters,
+            start_time=datetime.now(timezone.utc),
+        )
+        return statement, parameters
+
+    def after_cursor_execute(
+        self,
+        conn: Any,
+        cursor: Any,
+        statement: Union[str, TextClause],
+        parameters: Optional[Dict[str, Any]],
+        context: Any,
+        executemany: bool,
+    ) -> None:
+        """Event listener for after cursor execute"""
+        if self._current_query:
+            query = self._current_query
+            query.end_time = datetime.now(timezone.utc)
+            query.duration_ms = (
+                query.end_time - query.start_time
+            ).total_seconds() * 1000
+
+            logger.debug(
+                "Query execution details:\n"
+                f"  Start Time: {query.start_time}\n"
+                f"  End Time: {query.end_time}\n"
+                f"  Duration: {query.duration_ms:.2f} ms\n"
+                f"  Query: {query.statement}\n"
+                f"  Parameters: {query.parameters}"
+            )
+
+            self._current_query = None
+
+
+def attach_query_tracker(engine: Any):
+    """
+    Attach query tracking event listeners to a SQLAlchemy engine
+
+    Args:
+        engine: SQLAlchemy engine to attach listeners to
+
+    Returns:
+        QueryLogger instance that can be used to access query execution data
+    """
+    tracker = QueryLogger()
+
+    listen(
+        engine,
+        "before_cursor_execute",
+        tracker.before_cursor_execute,
+        retval=True,
+    )
+    listen(
+        engine,
+        "after_cursor_execute",
+        tracker.after_cursor_execute,
+    )

metadata/ingestion/connections/test_connections.py

@@ -38,7 +38,7 @@ from metadata.generated.schema.entity.services.connections.testConnectionResult
 )
 from metadata.generated.schema.type.basic import Timestamp
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
-from metadata.ingestion.source.connections import kill_active_connections
+from metadata.ingestion.source.connections_utils import kill_active_connections
 from metadata.profiler.orm.functions.conn_test import ConnTestFn
 from metadata.utils.constants import THREE_MIN
 from metadata.utils.logger import cli_logger

metadata/ingestion/ometa/mixins/tests_mixin.py

@@ -74,8 +74,8 @@ class OMetaTestsMixin:
         Returns:
             _type_: _description_
         """
-        resp = self.client.put(
-            f"{self.get_suffix(TestCase)}/{quote(test_case_fqn)}/testCaseResult",
+        resp = self.client.post(
+            f"{self.get_suffix(TestCaseResult)}/{quote(test_case_fqn)}",
             test_results.model_dump_json(),
         )
 
@@ -167,7 +167,6 @@ class OMetaTestsMixin:
         self,
         test_case_fqn: str,
         entity_link: Optional[str] = None,
-        test_suite_fqn: Optional[str] = None,
         test_definition_fqn: Optional[str] = None,
         test_case_parameter_values: Optional[List[TestCaseParameterValue]] = None,
     ):
@@ -196,7 +195,6 @@ class OMetaTestsMixin:
             CreateTestCaseRequest(
                 name=test_case_fqn.split(".")[-1],
                 entityLink=entity_link,
-                testSuite=test_suite_fqn,
                 testDefinition=test_definition_fqn,
                 parameterValues=test_case_parameter_values,
             )  # type: ignore
@@ -253,7 +251,7 @@ class OMetaTestsMixin:
         }
 
         resp = self.client.get(
-            f"/dataQuality/testCases/{test_case_fqn}/testCaseResult",
+            f"{self.get_suffix(TestCaseResult)}/{test_case_fqn}",
             params,
         )
 

metadata/ingestion/ometa/routes.py

@@ -167,6 +167,7 @@ from metadata.generated.schema.entity.teams.role import Role
 from metadata.generated.schema.entity.teams.team import Team
 from metadata.generated.schema.entity.teams.user import AuthenticationMechanism, User
 from metadata.generated.schema.settings.settings import Settings
+from metadata.generated.schema.tests.basic import TestCaseResult
 from metadata.generated.schema.tests.testCase import TestCase
 from metadata.generated.schema.tests.testDefinition import TestDefinition
 from metadata.generated.schema.tests.testSuite import TestSuite
@@ -264,6 +265,7 @@ ROUTES = {
     TestSuite.__name__: "/dataQuality/testSuites",
     CreateTestSuiteRequest.__name__: "/dataQuality/testSuites",
     TestCase.__name__: "/dataQuality/testCases",
+    TestCaseResult.__name__: "/dataQuality/testCases/testCaseResults",
     CreateTestCaseRequest.__name__: "/dataQuality/testCases",
     # Analytics
     WebAnalyticEventData.__name__: "/analytics/web/events/collect",

metadata/ingestion/sink/metadata_rest.py

@@ -79,7 +79,7 @@ from metadata.ingestion.models.tests_data import (
     OMetaTestSuiteSample,
 )
 from metadata.ingestion.models.user import OMetaUserProfile
-from metadata.ingestion.ometa.client import APIError
+from metadata.ingestion.ometa.client import APIError, LimitsException
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.dashboard.dashboard_service import DashboardUsage
 from metadata.ingestion.source.database.database_service import DataModelLink
@@ -118,6 +118,7 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
         self.metadata = metadata
         self.role_entities = {}
         self.team_entities = {}
+        self.limit_reached = set()
 
     @classmethod
     def create(
@@ -166,16 +167,30 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
         Send to OM the request creation received as is.
         :param entity_request: Create Entity request
         """
-        created = self.metadata.create_or_update(entity_request)
-        if created:
-            return Either(right=created)
+        if type(entity_request).__name__ in self.limit_reached:
+            # If the limit has been reached, we don't need to try to ingest the entity
+            # Note: We use PatchRequest to update the entity, so updating is not affected by the limit
+            return None
+        try:
+            created = self.metadata.create_or_update(entity_request)
+            if created:
+                return Either(right=created)
 
-        error = f"Failed to ingest {type(entity_request).__name__}"
-        return Either(
-            left=StackTraceError(
-                name=type(entity_request).__name__, error=error, stackTrace=None
+            error = f"Failed to ingest {type(entity_request).__name__}"
+            return Either(
+                left=StackTraceError(
+                    name=type(entity_request).__name__, error=error, stackTrace=None
+                )
+            )
+        except LimitsException as _:
+            self.limit_reached.add(type(entity_request).__name__)
+            return Either(
+                left=StackTraceError(
+                    name=type(entity_request).__name__,
+                    error=f"Limit reached for {type(entity_request).__name__}",
+                    stackTrace=None,
+                )
             )
-        )
 
     @_run_dispatch.register
     def patch_entity(self, record: PatchRequest) -> Either[Entity]:
@@ -329,12 +344,26 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
             team = self.metadata.create_or_update(create_team)
             self.team_entities[team.name.root] = str(team.id.root)
             return team
+        except LimitsException as _:
+            if type(create_team).__name__ in self.limit_reached:
+                # Note: We do not have a way to patch the team,
+                # so we try to put and handle exception
+                return None
+            self.limit_reached.add(type(create_team).__name__)
+            return Either(
+                left=StackTraceError(
+                    name=type(create_team).__name__,
+                    error=f"Limit reached for {type(create_team).__name__}",
+                    stackTrace=None,
+                )
+            )
         except Exception as exc:
             logger.debug(traceback.format_exc())
             logger.error(f"Unexpected error creating team [{create_team}]: {exc}")
 
         return None
 
+    # pylint: disable=too-many-branches
     @_run_dispatch.register
     def write_users(self, record: OMetaUserProfile) -> Either[User]:
         """
@@ -388,8 +417,22 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
         metadata_user = CreateUserRequest(**user_profile)
 
         # Create user
-        user = self.metadata.create_or_update(metadata_user)
-        return Either(right=user)
+        try:
+            user = self.metadata.create_or_update(metadata_user)
+            return Either(right=user)
+        except LimitsException as _:
+            if type(metadata_user).__name__ in self.limit_reached:
+                # Note: We do not have a way to patch the user,
+                # so we try to put and handle exception
+                return None
+            self.limit_reached.add(type(metadata_user).__name__)
+            return Either(
+                left=StackTraceError(
+                    name=type(metadata_user).__name__,
+                    error=f"Limit reached for {type(metadata_user).__name__}",
+                    stackTrace=None,
+                )
+            )
 
     @_run_dispatch.register
     def delete_entity(self, record: DeleteEntity) -> Either[Entity]:

metadata/ingestion/source/api/api_service.py

@@ -39,9 +39,6 @@ from metadata.ingestion.api.delete import delete_entity_from_source
 from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import Source
 from metadata.ingestion.api.topology_runner import TopologyRunnerMixin
-from metadata.ingestion.connections.test_connections import (
-    raise_test_connection_exception,
-)
 from metadata.ingestion.models.delete_entity import DeleteEntity
 from metadata.ingestion.models.topology import (
     NodeStage,
@@ -50,7 +47,7 @@ from metadata.ingestion.models.topology import (
     TopologyNode,
 )
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
-from metadata.ingestion.source.connections import get_connection, get_test_connection_fn
+from metadata.ingestion.source.connections import get_connection, test_connection_common
 from metadata.utils import fqn
 from metadata.utils.logger import ingestion_logger
 
@@ -177,11 +174,9 @@ class ApiServiceSource(TopologyRunnerMixin, Source, ABC):
         """By default, nothing to close"""
 
     def test_connection(self) -> None:
-        test_connection_fn = get_test_connection_fn(self.service_connection)
-        result = test_connection_fn(
+        test_connection_common(
             self.metadata, self.connection_obj, self.service_connection
         )
-        raise_test_connection_exception(result)
 
     def mark_api_collections_as_deleted(self) -> Iterable[Either[DeleteEntity]]:
         """Method to mark the api collection as deleted"""

metadata/ingestion/source/api/rest/metadata.py

@@ -362,7 +362,6 @@ class RestSource(ApiServiceSource):
                         FieldModel(
                             name=key,
                             dataType=DataTypeTopic.UNKNOWN,
-                            dataTypeDisplay="OBJECT",
                             children=children,
                         )
                     )

metadata/ingestion/source/connections.py

@@ -14,11 +14,16 @@ Main entrypoints to create and test connections
 for any source.
 """
 import traceback
-from typing import Any, Callable
+from typing import Any, Callable, Optional, Type
 
 from pydantic import BaseModel
-from sqlalchemy.engine import Engine
 
+from metadata.ingestion.connections.connection import BaseConnection
+from metadata.ingestion.connections.test_connections import (
+    raise_test_connection_exception,
+)
+from metadata.ingestion.ometa.ometa_api import OpenMetadata
+from metadata.utils.class_helper import get_service_type_from_source_type
 from metadata.utils.importer import import_connection_fn
 from metadata.utils.logger import cli_logger
 
@@ -28,10 +33,71 @@ GET_CONNECTION_FN_NAME = "get_connection"
 TEST_CONNECTION_FN_NAME = "test_connection"
 
 
+# TODO: This is a temporary solution to get the connection class from the service spec.
+# Once we migrate all connectors we shouldn't need this.
+def _get_connection_class_from_spec(
+    connection: BaseModel,
+) -> Optional[Type[BaseConnection]]:
+    """
+    Helper method to get the connection class from the connection spec.
+    Returns the connection class if successful, None otherwise.
+    """
+    from metadata.utils.service_spec.service_spec import (  # pylint: disable=import-outside-toplevel
+        BaseSpec,
+        import_connection_class,
+    )
+
+    connection_type = getattr(connection, "type", None)
+    if connection_type:
+        service_type = get_service_type_from_source_type(connection_type.value)
+        try:
+            spec = BaseSpec.get_for_source(service_type, connection_type.value.lower())
+            if getattr(spec, "connection_class", None):
+                connection_class = import_connection_class(
+                    service_type, connection_type.value.lower()
+                )
+                return connection_class
+        except Exception:
+            logger.error(
+                f"Error importing connection class for {connection_type.value}"
+            )
+            logger.debug(traceback.format_exc())
+    return None
+
+
+def _get_connection_fn_from_service_spec(connection: BaseModel) -> Optional[Callable]:
+    """
+    Import the get_connection function from the source, or use ServiceSpec connection_class if defined.
+    """
+    connection_class = _get_connection_class_from_spec(connection)
+    if connection_class:
+
+        def _get_client(conn):
+            return connection_class(conn).get_client()
+
+        return _get_client
+    return None
+
+
+def _get_test_fn_from_service_spec(connection: BaseModel) -> Optional[Callable]:
+    """
+    Import the get_connection function from the source, or use ServiceSpec connection_class if defined.
+    """
+    connection_class = _get_connection_class_from_spec(connection)
+    if connection_class:
+        return connection_class(connection).test_connection
+    return None
+
+
 def get_connection_fn(connection: BaseModel) -> Callable:
     """
-    Import the get_connection function from the source
+    Import the get_connection function from the source, or use ServiceSpec connection_class if defined.
     """
+    # Try ServiceSpec path first
+    connection_fn = _get_connection_fn_from_service_spec(connection)
+    if connection_fn:
+        return connection_fn
+    # Fallback to default
     return import_connection_fn(
         connection=connection, function_name=GET_CONNECTION_FN_NAME
     )
@@ -41,6 +107,10 @@ def get_test_connection_fn(connection: BaseModel) -> Callable:
     """
     Import the test_connection function from the source
     """
+    test_fn = _get_test_fn_from_service_spec(connection)
+    if test_fn:
+        return test_fn
+    # Fallback to default
     return import_connection_fn(
         connection=connection, function_name=TEST_CONNECTION_FN_NAME
     )
@@ -54,15 +124,11 @@ def get_connection(connection: BaseModel) -> Any:
     return get_connection_fn(connection)(connection)
 
 
-def kill_active_connections(engine: Engine):
-    """
-    Method to kill the active connections
-    as well as idle connections in the engine
-    """
+def test_connection_common(metadata: OpenMetadata, connection_obj, service_connection):
+    test_connection_fn = get_test_connection_fn(service_connection)
+    # TODO: Remove this once we migrate all connectors to use the new test connection function
     try:
-        active_conn = engine.pool.checkedout() + engine.pool.checkedin()
-        if active_conn:
-            engine.dispose()
-    except Exception as exc:
-        logger.warning(f"Error Killing the active connections {exc}")
-        logger.debug(traceback.format_exc())
+        result = test_connection_fn(metadata)
+    except TypeError:
+        result = test_connection_fn(metadata, connection_obj, service_connection)
+    raise_test_connection_exception(result)

metadata/ingestion/source/connections_utils.py

@@ -0,0 +1,32 @@
+#  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.
+
+import traceback
+
+from sqlalchemy.engine import Engine
+
+from metadata.utils.logger import cli_logger
+
+logger = cli_logger()
+
+
+def kill_active_connections(engine: Engine):
+    """
+    Method to kill the active connections
+    as well as idle connections in the engine
+    """
+    try:
+        active_conn = engine.pool.checkedout() + engine.pool.checkedin()
+        if active_conn:
+            engine.dispose()
+    except Exception as exc:
+        logger.warning(f"Error Killing the active connections {exc}")
+        logger.debug(traceback.format_exc())

metadata/ingestion/source/dashboard/dashboard_service.py

@@ -55,9 +55,6 @@ from metadata.ingestion.api.delete import delete_entity_from_source
 from metadata.ingestion.api.models import Either, Entity
 from metadata.ingestion.api.steps import Source
 from metadata.ingestion.api.topology_runner import C, TopologyRunnerMixin
-from metadata.ingestion.connections.test_connections import (
-    raise_test_connection_exception,
-)
 from metadata.ingestion.lineage.sql_lineage import get_column_fqn
 from metadata.ingestion.models.delete_entity import DeleteEntity
 from metadata.ingestion.models.ometa_classification import OMetaTagAndClassification
@@ -70,7 +67,7 @@ from metadata.ingestion.models.topology import (
     TopologyNode,
 )
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
-from metadata.ingestion.source.connections import get_connection, get_test_connection_fn
+from metadata.ingestion.source.connections import get_connection, test_connection_common
 from metadata.utils import fqn
 from metadata.utils.filters import filter_by_dashboard, filter_by_project
 from metadata.utils.logger import ingestion_logger
@@ -595,11 +592,9 @@ class DashboardServiceSource(TopologyRunnerMixin, Source, ABC):
             yield dashboard_details
 
     def test_connection(self) -> None:
-        test_connection_fn = get_test_connection_fn(self.service_connection)
-        result = test_connection_fn(
+        test_connection_common(
             self.metadata, self.connection_obj, self.service_connection
         )
-        raise_test_connection_exception(result)
 
     def prepare(self):
         """By default, nothing to prepare"""

metadata/ingestion/source/dashboard/qlikcloud/client.py

@@ -12,6 +12,7 @@
 REST Auth & Client for QlikCloud
 """
 import json
+import re
 import traceback
 from typing import Dict, Iterable, List, Optional
 
@@ -23,12 +24,14 @@ from metadata.ingestion.source.dashboard.qlikcloud.constants import (
     APP_LOADMODEL_REQ,
     CREATE_SHEET_SESSION,
     GET_LOADMODEL_LAYOUT,
+    GET_SCRIPT,
     GET_SHEET_LAYOUT,
     OPEN_DOC_REQ,
 )
 from metadata.ingestion.source.dashboard.qlikcloud.models import (
     QlikApp,
     QlikAppResponse,
+    QlikScriptResult,
     QlikSpace,
     QlikSpaceResponse,
 )
@@ -173,12 +176,18 @@ class QlikCloudClient:
             models = self._websocket_send_request(GET_LOADMODEL_LAYOUT, response=True)
             data_models = QlikDataModelResult(**models)
             layout = data_models.result.qLayout
+            parsed_datamodels = []
             if isinstance(layout, list):
                 tables = []
                 for layout in data_models.result.qLayout:
                     tables.extend(layout.value.tables)
-                return tables
-            return layout.tables
+                parsed_datamodels.extend(tables)
+            else:
+                parsed_datamodels.extend(layout.tables)
+            script_tables = self.get_script_tables()
+            if script_tables:
+                parsed_datamodels.extend(script_tables)
+            return parsed_datamodels
         except Exception:
             logger.debug(traceback.format_exc())
             logger.warning("Failed to fetch the dashboard datamodels")
@@ -204,3 +213,26 @@ class QlikCloudClient:
         except Exception:
             logger.debug(traceback.format_exc())
             logger.warning("Failed to fetch the space list")
+
+    def get_script_tables(self) -> Optional[List[QlikTable]]:
+        """Get script tables from the dashboard script"""
+        script_tables = []
+        try:
+            script_response = self._websocket_send_request(GET_SCRIPT, response=True)
+            script_result = QlikScriptResult(**script_response)
+            if script_result.result.qScript:
+                script_value = script_result.result.qScript
+                matches = re.findall(
+                    r'FROM\s+["\']?([a-zA-Z0-9_.]+)["\']?', script_value, re.IGNORECASE
+                )
+                if isinstance(matches, list):
+                    for table in matches:
+                        table_name = table.split(".")[-1]
+                        script_tables.append(QlikTable(tableName=table_name))
+            if not script_tables:
+                logger.warning("No script tables found")
+            return script_tables
+        except Exception:
+            logger.debug(traceback.format_exc())
+            logger.warning("Failed to fetch the script tables")
+        return script_tables

metadata/ingestion/source/dashboard/qlikcloud/constants.py

@@ -64,3 +64,9 @@ GET_LOADMODEL_LAYOUT = {
     "id": 5,
     "jsonrpc": "2.0",
 }
+GET_SCRIPT = {
+    "handle": 3,
+    "method": "GetScript",
+    "id": 1,
+    "jsonrpc": "2.0",
+}

metadata/ingestion/source/dashboard/qlikcloud/models.py

@@ -84,3 +84,11 @@ class QlikAppResponse(BaseModel):
 
     apps: Optional[List[QlikApp]] = Field(None, alias="data")
     links: Optional[QlikLinks] = None
+
+
+class QlikScript(BaseModel):
+    qScript: Optional[str] = None
+
+
+class QlikScriptResult(BaseModel):
+    result: Optional[QlikScript] = QlikScript()

metadata/ingestion/source/dashboard/superset/connection.py

@@ -24,7 +24,7 @@ from metadata.generated.schema.entity.services.connections.dashboard.supersetCon
     SupersetConnection,
 )
 from metadata.generated.schema.entity.services.connections.database.mysqlConnection import (
-    MysqlConnection,
+    MysqlConnection as MysqlConnectionConfig,
 )
 from metadata.generated.schema.entity.services.connections.database.postgresConnection import (
     PostgresConnection,
@@ -46,16 +46,16 @@ from metadata.ingestion.source.dashboard.superset.queries import (
     FETCH_ALL_CHARTS_TEST,
     FETCH_DASHBOARDS_TEST,
 )
-from metadata.ingestion.source.database.mysql.connection import (
-    get_connection as mysql_get_connection,
-)
+from metadata.ingestion.source.database.mysql.connection import MySQLConnection
 from metadata.ingestion.source.database.postgres.connection import (
     get_connection as pg_get_connection,
 )
 from metadata.utils.constants import THREE_MIN
 
 
-def get_connection(connection: SupersetConnection) -> SupersetAPIClient:
+def get_connection(
+    connection: SupersetConnection,
+) -> Union[SupersetAPIClient, Engine, None]:
     """
     Create connection
     """
@@ -63,8 +63,8 @@ def get_connection(connection: SupersetConnection) -> SupersetAPIClient:
         return SupersetAPIClient(connection)
     if isinstance(connection.connection, PostgresConnection):
         return pg_get_connection(connection=connection.connection)
-    if isinstance(connection.connection, MysqlConnection):
-        return mysql_get_connection(connection=connection.connection)
+    if isinstance(connection.connection, MysqlConnectionConfig):
+        return MySQLConnection(connection.connection).get_client()
     return None
 
 
@@ -89,7 +89,7 @@ def test_connection(
     else:
         test_fn["CheckAccess"] = partial(test_connection_engine_step, client)
         test_fn["GetDashboards"] = partial(test_query, client, FETCH_DASHBOARDS_TEST)
-        if isinstance(service_connection.connection, MysqlConnection):
+        if isinstance(service_connection.connection, MysqlConnectionConfig):
             test_fn["GetCharts"] = partial(
                 test_query, client, FETCH_ALL_CHARTS_TEST.replace('"', "`")
             )

metadata/ingestion/source/dashboard/superset/queries.py

@@ -93,7 +93,7 @@ LIMIT 1
 FETCH_COLUMN = """
 select 
 	tc.id, 
-    	tc.table_name ,
+    	t.table_name ,
     	tc.column_name, 
 		tc.table_id, 
     	tc.type,