openmetadata-ingestion 1.6.0.0rc2__py3-none-any.whl → 1.6.1.0__py3-none-any.whl

metadata/ingestion/source/database/snowflake/metadata.py

@@ -27,7 +27,10 @@ from metadata.generated.schema.api.data.createStoredProcedure import (
 )
 from metadata.generated.schema.entity.data.database import Database
 from metadata.generated.schema.entity.data.databaseSchema import DatabaseSchema
-from metadata.generated.schema.entity.data.storedProcedure import StoredProcedureCode
+from metadata.generated.schema.entity.data.storedProcedure import (
+    StoredProcedureCode,
+    StoredProcedureType,
+)
 from metadata.generated.schema.entity.data.table import (
     PartitionColumnDetails,
     PartitionIntervalTypes,
@@ -71,6 +74,7 @@ from metadata.ingestion.source.database.snowflake.models import (
     SnowflakeStoredProcedure,
 )
 from metadata.ingestion.source.database.snowflake.queries import (
+    SNOWFLAKE_DESC_FUNCTION,
     SNOWFLAKE_DESC_STORED_PROCEDURE,
     SNOWFLAKE_FETCH_ALL_TAGS,
     SNOWFLAKE_GET_CLUSTER_KEY,
@@ -78,6 +82,7 @@ from metadata.ingestion.source.database.snowflake.queries import (
     SNOWFLAKE_GET_DATABASE_COMMENTS,
     SNOWFLAKE_GET_DATABASES,
     SNOWFLAKE_GET_EXTERNAL_LOCATIONS,
+    SNOWFLAKE_GET_FUNCTIONS,
     SNOWFLAKE_GET_ORGANIZATION_NAME,
     SNOWFLAKE_GET_SCHEMA_COMMENTS,
     SNOWFLAKE_GET_STORED_PROCEDURES,
@@ -623,26 +628,34 @@ class SnowflakeSource(
 
         return views
 
+    def _get_stored_procedures_internal(
+        self, query: str
+    ) -> Iterable[SnowflakeStoredProcedure]:
+        results = self.engine.execute(
+            query.format(
+                database_name=self.context.get().database,
+                schema_name=self.context.get().database_schema,
+            )
+        ).all()
+        for row in results:
+            stored_procedure = SnowflakeStoredProcedure.model_validate(dict(row))
+            if stored_procedure.definition is None:
+                logger.debug(
+                    f"Missing ownership permissions on procedure {stored_procedure.name}."
+                    " Trying to fetch description via DESCRIBE."
+                )
+                stored_procedure.definition = self.describe_procedure_definition(
+                    stored_procedure
+                )
+            yield stored_procedure
+
     def get_stored_procedures(self) -> Iterable[SnowflakeStoredProcedure]:
         """List Snowflake stored procedures"""
         if self.source_config.includeStoredProcedures:
-            results = self.engine.execute(
-                SNOWFLAKE_GET_STORED_PROCEDURES.format(
-                    database_name=self.context.get().database,
-                    schema_name=self.context.get().database_schema,
-                )
-            ).all()
-            for row in results:
-                stored_procedure = SnowflakeStoredProcedure.model_validate(dict(row))
-                if stored_procedure.definition is None:
-                    logger.debug(
-                        f"Missing ownership permissions on procedure {stored_procedure.name}."
-                        " Trying to fetch description via DESCRIBE."
-                    )
-                    stored_procedure.definition = self.describe_procedure_definition(
-                        stored_procedure
-                    )
-                yield stored_procedure
+            yield from self._get_stored_procedures_internal(
+                SNOWFLAKE_GET_STORED_PROCEDURES
+            )
+            yield from self._get_stored_procedures_internal(SNOWFLAKE_GET_FUNCTIONS)
 
     def describe_procedure_definition(
         self, stored_procedure: SnowflakeStoredProcedure
@@ -654,8 +667,12 @@ class SnowflakeSource(
         Then, if the procedure is created with `EXECUTE AS CALLER`, we can still try to
         get the definition with a DESCRIBE.
         """
+        if stored_procedure.procedure_type == StoredProcedureType.StoredProcedure.value:
+            query = SNOWFLAKE_DESC_STORED_PROCEDURE
+        else:
+            query = SNOWFLAKE_DESC_FUNCTION
         res = self.engine.execute(
-            SNOWFLAKE_DESC_STORED_PROCEDURE.format(
+            query.format(
                 database_name=self.context.get().database,
                 schema_name=self.context.get().database_schema,
                 procedure_name=stored_procedure.name,
@@ -677,6 +694,8 @@ class SnowflakeSource(
                     language=STORED_PROC_LANGUAGE_MAP.get(stored_procedure.language),
                     code=stored_procedure.definition,
                 ),
+                storedProcedureType=stored_procedure.procedure_type
+                or StoredProcedureType.StoredProcedure.value,
                 databaseSchema=fqn.build(
                     metadata=self.metadata,
                     entity_type=DatabaseSchema,

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

@@ -50,6 +50,7 @@ class SnowflakeStoredProcedure(BaseModel):
         None, alias="SIGNATURE", description="Used to build the source URL"
     )
     comment: Optional[str] = Field(None, alias="COMMENT")
+    procedure_type: Optional[str] = Field(None, alias="PROCEDURE_TYPE")
 
     # Update the signature to clean it up on read
     @field_validator("signature")

metadata/ingestion/source/database/snowflake/profiler/system.py

@@ -20,6 +20,7 @@ from metadata.profiler.metrics.system.system import (
     SQASessionProvider,
     SystemMetricsComputer,
 )
+from metadata.profiler.processor.runner import QueryRunner
 from metadata.utils.collections import CaseInsensitiveString
 from metadata.utils.logger import profiler_logger
 from metadata.utils.lru_cache import LRU_CACHE_SIZE, LRUCache
@@ -294,11 +295,11 @@ class SnowflakeSystemMetricsSource(
         )
 
     def get_kwargs(self, **kwargs):
-        table = kwargs.get("table")
+        runner: QueryRunner = kwargs.get("runner")
         return {
-            "table": table.__table__.name,
-            "database": self.get_session().get_bind().url.database,
-            "schema": table.__table__.schema,
+            "table": runner.table_name,
+            "database": runner.session.get_bind().url.database,
+            "schema": runner.schema_name,
         }
 
     def get_inserts(self, **kwargs) -> List[SystemProfile]:

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

@@ -294,17 +294,38 @@ SELECT
   PROCEDURE_LANGUAGE AS language,
   PROCEDURE_DEFINITION AS definition,
   ARGUMENT_SIGNATURE AS signature,
-  COMMENT as comment
+  COMMENT as comment,
+  'StoredProcedure' as procedure_type
 FROM INFORMATION_SCHEMA.PROCEDURES
 WHERE PROCEDURE_CATALOG = '{database_name}'
   AND PROCEDURE_SCHEMA = '{schema_name}'
     """
 )
 
+SNOWFLAKE_GET_FUNCTIONS = textwrap.dedent(
+    """
+SELECT
+  FUNCTION_NAME AS name,
+  FUNCTION_OWNER AS owner,
+  FUNCTION_LANGUAGE AS language,
+  FUNCTION_DEFINITION AS definition,
+  ARGUMENT_SIGNATURE AS signature,
+  COMMENT as comment,
+  'UDF' as procedure_type
+FROM INFORMATION_SCHEMA.FUNCTIONS
+WHERE FUNCTION_CATALOG = '{database_name}'
+  AND FUNCTION_SCHEMA = '{schema_name}'
+    """
+)
+
 SNOWFLAKE_DESC_STORED_PROCEDURE = (
     "DESC PROCEDURE {database_name}.{schema_name}.{procedure_name}{procedure_signature}"
 )
 
+SNOWFLAKE_DESC_FUNCTION = (
+    "DESC FUNCTION {database_name}.{schema_name}.{procedure_name}{procedure_signature}"
+)
+
 SNOWFLAKE_GET_STORED_PROCEDURE_QUERIES = textwrap.dedent(
     """
 WITH SP_HISTORY AS (

metadata/ingestion/source/database/stored_procedures_mixin.py

@@ -217,14 +217,26 @@ class StoredProcedureLineageMixin(ABC):
         self, procedure_and_query: ProcedureAndQuery
     ) -> Iterable[Either[Union[AddLineageRequest, CreateQueryRequest]]]:
 
-        yield from self._yield_procedure_lineage(
-            query_by_procedure=procedure_and_query.query_by_procedure,
-            procedure=procedure_and_query.procedure,
-        )
-        yield from self.yield_procedure_query(
-            query_by_procedure=procedure_and_query.query_by_procedure,
-            procedure=procedure_and_query.procedure,
-        )
+        try:
+            yield from self._yield_procedure_lineage(
+                query_by_procedure=procedure_and_query.query_by_procedure,
+                procedure=procedure_and_query.procedure,
+            )
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.warning(
+                f"Could not get lineage for store procedure '{procedure_and_query.procedure.fullyQualifiedName}' due to [{exc}]."
+            )
+        try:
+            yield from self.yield_procedure_query(
+                query_by_procedure=procedure_and_query.query_by_procedure,
+                procedure=procedure_and_query.procedure,
+            )
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.warning(
+                f"Could not get query for store procedure '{procedure_and_query.procedure.fullyQualifiedName}' due to [{exc}]."
+            )
 
     def procedure_lineage_generator(self) -> Iterable[ProcedureAndQuery]:
         query = {

metadata/ingestion/source/pipeline/fivetran/metadata.py

@@ -275,7 +275,7 @@ class FivetranSource(PipelineServiceSource):
                 )
 
     def get_pipeline_name(self, pipeline_details: FivetranPipelineDetails) -> str:
-        return pipeline_details.pipeline_name
+        return pipeline_details.pipeline_display_name or pipeline_details.pipeline_name
 
     def get_source_url(
         self,

metadata/ingestion/source/pipeline/kafkaconnect/client.py

@@ -61,15 +61,18 @@ class KafkaConnectClient:
         """
         Get the version and other details of the Kafka Connect cluster.
         """
-        try:
-            result = self.client.get_cluster_info()
-            return result
-
-        except Exception as exc:
-            logger.debug(traceback.format_exc())
-            logger.error(f"Unable to get cluster info :{exc}")
+        return self.client.get_cluster_info()
 
-        return None
+    def get_connectors_list(
+        self,
+        expand: str = None,
+        pattern: str = None,
+        state: str = None,
+    ) -> dict:
+        """
+        Get the list of connectors from Kafka Connect cluster.
+        """
+        return self.client.list_connectors(expand=expand, pattern=pattern, state=state)
 
     def get_connectors(
         self,
@@ -85,12 +88,8 @@ class KafkaConnectClient:
             pattern (str): Only list connectors that match the regex pattern.
             state (str): Only list connectors that match the state.
         """
-
         try:
-            result = self.client.list_connectors(
-                expand=expand, pattern=pattern, state=state
-            )
-            return result
+            return self.get_connectors_list(expand=expand, pattern=pattern, state=state)
         except Exception as exc:
             logger.debug(traceback.format_exc())
             logger.error(f"Unable to get connectors list {exc}")

metadata/ingestion/source/pipeline/kafkaconnect/connection.py

@@ -51,7 +51,7 @@ def test_connection(
 
     test_fn = {
         "GetClusterInfo": client.get_cluster_info,
-        "GetPipelines": client.get_connectors,
+        "GetPipelines": client.get_connectors_list,
         "GetPlugins": client.get_connector_plugins,
     }
 

metadata/profiler/interface/sqlalchemy/profiler_interface.py

@@ -372,7 +372,7 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
             dictionnary of results
         """
         logger.debug(f"Computing system metrics for {runner.table_name}")
-        return self.system_metrics_computer.get_system_metrics(table=runner.dataset)
+        return self.system_metrics_computer.get_system_metrics(runner=runner)
 
     def _create_thread_safe_runner(self, session, column=None):
         """Create thread safe runner"""

metadata/profiler/metrics/static/max.py

@@ -88,10 +88,12 @@ class Max(StaticMetric):
     def fn(self):
         """sqlalchemy function"""
         if is_concatenable(self.col.type):
-            return MaxFn(LenFn(column(self.col.name, self.col.type)))
+            return MaxFn(
+                LenFn(column(self.col.name, self.col.type)), type_=self.col.type
+            )
         if (not is_quantifiable(self.col.type)) and (not is_date_time(self.col.type)):
             return None
-        return MaxFn(column(self.col.name, self.col.type))
+        return MaxFn(column(self.col.name, self.col.type), type_=self.col.type)
 
     def df_fn(self, dfs=None):
         """pandas function"""

metadata/profiler/metrics/static/min.py

@@ -88,11 +88,13 @@ class Min(StaticMetric):
     def fn(self):
         """sqlalchemy function"""
         if is_concatenable(self.col.type):
-            return MinFn(LenFn(column(self.col.name, self.col.type)))
+            return MinFn(
+                LenFn(column(self.col.name, self.col.type)), type_=self.col.type
+            )
 
         if (not is_quantifiable(self.col.type)) and (not is_date_time(self.col.type)):
             return None
-        return MinFn(column(self.col.name, self.col.type))
+        return MinFn(column(self.col.name, self.col.type), type_=self.col.type)
 
     def df_fn(self, dfs=None):
         """pandas function"""

metadata/profiler/orm/converter/converter_registry.py

@@ -19,6 +19,7 @@ from metadata.generated.schema.entity.services.databaseService import (
 )
 from metadata.profiler.orm.converter.bigquery.converter import BigqueryMapTypes
 from metadata.profiler.orm.converter.common import CommonMapTypes
+from metadata.profiler.orm.converter.mssql.converter import MssqlMapTypes
 from metadata.profiler.orm.converter.redshift.converter import RedshiftMapTypes
 from metadata.profiler.orm.converter.snowflake.converter import SnowflakeMapTypes
 
@@ -26,3 +27,4 @@ converter_registry = defaultdict(lambda: CommonMapTypes)
 converter_registry[DatabaseServiceType.BigQuery] = BigqueryMapTypes
 converter_registry[DatabaseServiceType.Snowflake] = SnowflakeMapTypes
 converter_registry[DatabaseServiceType.Redshift] = RedshiftMapTypes
+converter_registry[DatabaseServiceType.Mssql] = MssqlMapTypes

metadata/profiler/orm/converter/mssql/converter.py

@@ -16,10 +16,24 @@ Map Types to convert/cast mssql related data types to relevant data types
 
 from sqlalchemy import NVARCHAR, TEXT
 
-from metadata.profiler.orm.registry import CustomImage
+from metadata.profiler.orm.converter.common import CommonMapTypes
+from metadata.profiler.orm.registry import CustomImage, CustomTypes, DataType
 
 cast_dict = {
     CustomImage: "VARBINARY(max)",
     TEXT: "VARCHAR(max)",
     NVARCHAR: "NVARCHAR(max)",
 }
+
+
+class MssqlMapTypes(CommonMapTypes):
+    """
+    Mssql type mapper
+    """
+
+    def __init__(self) -> None:
+        self._TYPE_MAP.update(
+            {
+                DataType.TIMESTAMP: CustomTypes.TIMESTAMP.value,
+            }
+        )

metadata/profiler/orm/functions/md5.py

@@ -10,15 +10,13 @@
 #  limitations under the License.
 
 """
-Define Concat function
+Define MD5 hashing function
 """
-# Keep SQA docs style defining custom constructs
-
 from sqlalchemy.ext.compiler import compiles
 from sqlalchemy.sql.functions import FunctionElement
 
 from metadata.profiler.metrics.core import CACHE
-from metadata.profiler.orm.registry import Dialects
+from metadata.profiler.orm.registry import PythonDialects
 from metadata.utils.logger import profiler_logger
 
 logger = profiler_logger()
@@ -33,7 +31,12 @@ def _(element, compiler, **kw):
     return f"MD5({compiler.process(element.clauses, **kw)})"
 
 
-@compiles(MD5, Dialects.MSSQL)
+@compiles(MD5, PythonDialects.MSSQL.value)
 def _(element, compiler, **kw):
     # TODO requires separate where clauses for each table
     return f"CONVERT(VARCHAR(8), HashBytes('MD5', {compiler.process(element.clauses, **kw)}), 2)"
+
+
+@compiles(MD5, PythonDialects.BigQuery.value)
+def _(element, compiler, **kw):
+    return f"TO_HEX(MD5(CAST({compiler.process(element.clauses, **kw)} AS STRING)))"

metadata/profiler/orm/functions/table_metric_computer.py

@@ -91,8 +91,8 @@ class AbstractTableMetricComputer(ABC):
             table (DeclarativeMeta): _description_
         """
         try:
-            self._schema_name = self.table.schema
-            self._table_name = self.table.name
+            self._schema_name = self.runner.schema_name
+            self._table_name = self.runner.table_name
         except AttributeError:
             raise AttributeError(ERROR_MSG)
 
@@ -119,10 +119,10 @@ class AbstractTableMetricComputer(ABC):
         Returns:
             Tuple[str, int]
         """
-        col_names = literal(",".join(inspect(self.table).c.keys()), type_=String).label(
-            COLUMN_NAMES
-        )
-        col_count = literal(len(inspect(self.table).c)).label(COLUMN_COUNT)
+        col_names = literal(
+            ",".join(inspect(self.runner.raw_dataset).c.keys()), type_=String
+        ).label(COLUMN_NAMES)
+        col_count = literal(len(inspect(self.runner.raw_dataset).c)).label(COLUMN_COUNT)
         return col_names, col_count
 
     def _build_query(

metadata/profiler/orm/types/custom_timestamp.py

@@ -45,6 +45,8 @@ class CustomTimestamp(TypeDecorator):
         import struct  # pylint: disable=import-outside-toplevel
 
         if dialect.name == "mssql" and isinstance(value, bytes):
-            bytes_to_int = struct.unpack(">Q", value)[0]
-            return bytes_to_int
+            unpacked_value = struct.unpack("@Q", value)
+            if unpacked_value:
+                return unpacked_value[0]
+            return None
         return value

metadata/profiler/processor/runner.py

@@ -83,6 +83,11 @@ class QueryRunner:
         """Table name attribute access"""
         return self.raw_dataset.__table__.schema
 
+    @property
+    def session(self):
+        """Table name attribute access"""
+        return self._session
+
     def _build_query(self, *entities, **kwargs) -> Query:
         """Build query object
 

metadata/profiler/source/database/base/profiler_source.py

@@ -154,7 +154,6 @@ class ProfilerSource(ProfilerSourceInterface):
                 profile_sample_type=self.source_config.profileSampleType,
                 sampling_method_type=self.source_config.samplingMethodType,
             ),
-            default_sample_data_count=self.source_config.sampleDataCount,
         )
 
         profiler_interface: ProfilerInterface = profiler_class.create(

metadata/sampler/processor.py

@@ -88,11 +88,7 @@ class SamplerProcessor(Processor):
                 schema_entity=schema_entity,
                 database_entity=database_entity,
                 table_config=get_config_for_table(entity, self.profiler_config),
-                default_sample_config=SampleConfig(
-                    profile_sample=self.source_config.profileSample,
-                    profile_sample_type=self.source_config.profileSampleType,
-                    sampling_method_type=self.source_config.samplingMethodType,
-                ),
+                default_sample_config=SampleConfig(),
                 default_sample_data_count=self.source_config.sampleDataCount,
             )
             sample_data = SampleData(

metadata/sampler/sqlalchemy/mssql/sampler.py

@@ -0,0 +1,50 @@
+#  Copyright 2021 Collate
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  http://www.apache.org/licenses/LICENSE-2.0
+#  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.
+"""
+Helper module to handle data sampling
+for the profiler
+"""
+
+
+from sqlalchemy import Table, text
+from sqlalchemy.sql.selectable import CTE
+
+from metadata.generated.schema.entity.data.table import ProfileSampleType
+from metadata.sampler.sqlalchemy.sampler import SQASampler
+
+
+class MssqlSampler(SQASampler):
+    """
+    Generates a sample of the data to not
+    run the query in the whole table.
+    """
+
+    def set_tablesample(self, selectable: Table):
+        """Set the TABLESAMPLE clause for MSSQL
+        Args:
+            selectable (Table): _description_
+        """
+        if self.sample_config.profile_sample_type == ProfileSampleType.PERCENTAGE:
+            return selectable.tablesample(
+                text(f"{self.sample_config.profile_sample or 100} PERCENT")
+            )
+
+        return selectable.tablesample(
+            text(f"{int(self.sample_config.profile_sample or 100)} ROWS")
+        )
+
+    def get_sample_query(self, *, column=None) -> CTE:
+        """get query for sample data"""
+        rnd = self._base_sample_query(column).cte(
+            f"{self.raw_dataset.__tablename__}_rnd"
+        )
+        query = self.client.query(rnd)
+        return query.cte(f"{self.raw_dataset.__tablename__}_sample")

metadata/sampler/sqlalchemy/sampler.py

@@ -223,8 +223,11 @@ class SQASampler(SamplerInterface, SQAInterfaceMixin):
         if not is_safe_sql_query(self.sample_query):
             raise RuntimeError(f"SQL expression is not safe\n\n{self.sample_query}")
 
-        return self.client.query(self.raw_dataset).from_statement(
-            text(f"{self.sample_query}")
+        stmt = text(f"{self.sample_query}")
+        stmt = stmt.columns(*list(inspect(self.raw_dataset).c))
+
+        return self.client.query(stmt.subquery()).cte(
+            f"{self.raw_dataset.__tablename__}_user_sampled"
         )
 
     def _partitioned_table(self) -> Query:

metadata/utils/class_helper.py

@@ -66,6 +66,9 @@ from metadata.generated.schema.metadataIngestion.testSuitePipeline import (
     TestSuitePipeline,
 )
 from metadata.generated.schema.metadataIngestion.workflow import SourceConfig
+from metadata.generated.schema.tests.testSuite import (
+    ServiceType as TestSuiteServiceType,
+)
 
 SERVICE_TYPE_REF = {
     ServiceType.Api.value: "apiService",
@@ -77,6 +80,8 @@ SERVICE_TYPE_REF = {
     ServiceType.Metadata.value: "metadataService",
     ServiceType.Search.value: "searchService",
     ServiceType.Storage.value: "storageService",
+    # We use test suites as "services" for DQ Ingestion Pipelines
+    TestSuiteServiceType.TestSuite.value: "testSuite",
 }
 
 SOURCE_CONFIG_TYPE_INGESTION = {
@@ -123,6 +128,8 @@ def get_pipeline_type_from_source_config(source_config: SourceConfig) -> Pipelin
 def _get_service_type_from(  # pylint: disable=inconsistent-return-statements
     service_subtype: str,
 ) -> ServiceType:
+    if service_subtype.lower() == "testsuite":
+        return TestSuiteServiceType.TestSuite
     for service_type in ServiceType:
         if service_subtype.lower() in [
             subtype.value.lower()

metadata/utils/importer.py

@@ -131,7 +131,7 @@ def import_from_module(key: str) -> Type[Any]:
     try:
         obj = getattr(importlib.import_module(module_name), obj_name)
         return obj
-    except ModuleNotFoundError as err:
+    except (ModuleNotFoundError, ImportError) as err:
         logger.debug(traceback.format_exc())
         raise DynamicImportException(module=module_name, key=obj_name, cause=err)
 

metadata/workflow/data_quality.py

@@ -22,6 +22,7 @@ from metadata.generated.schema.entity.services.connections.serviceConnection imp
 from metadata.generated.schema.entity.services.databaseService import DatabaseService
 from metadata.generated.schema.tests.testSuite import ServiceType, TestSuite
 from metadata.ingestion.api.steps import Processor, Sink
+from metadata.ingestion.ometa.utils import model_str
 from metadata.utils import fqn
 from metadata.utils.importer import import_sink_class
 from metadata.utils.logger import test_suite_logger
@@ -40,6 +41,7 @@ class TestSuiteWorkflow(IngestionWorkflow):
     """
 
     __test__ = False
+    service_type = ServiceType.TestSuite
 
     def set_steps(self):
         self.source = TestSuiteSource.create(self.config.model_dump(), self.metadata)
@@ -113,6 +115,8 @@ class TestSuiteWorkflow(IngestionWorkflow):
             fqn=fqn.build(
                 metadata=None,
                 entity_type=TestSuite,
-                table_fqn=self.config.source.sourceConfig.config.entityFullyQualifiedName,
+                table_fqn=model_str(
+                    self.config.source.sourceConfig.config.entityFullyQualifiedName
+                ),
             ),
         )