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

metadata/ingestion/source/dashboard/microstrategy/metadata.py

@@ -184,16 +184,23 @@ class MicrostrategySource(DashboardServiceSource):
     def yield_dashboard_lineage_details(
         self,
         dashboard_details: MstrDashboardDetails,
-        db_service_name: Optional[str] = None,
+        db_service_prefix: Optional[str] = None,
     ) -> Optional[Iterable[AddLineageRequest]]:
         """
-        Get lineage between datamodel and data sources
+        Get lineage between dashboard and data sources
         """
-        if not db_service_name:
+        if not db_service_prefix:
             return
 
+        (
+            prefix_db_service_name,
+            prefix_database_name,
+            prefix_schema_name,
+            prefix_table_name,
+        ) = self.parse_db_service_prefix(db_service_prefix)
+
         database_service = self.metadata.get_by_name(
-            entity=DatabaseService, fqn=db_service_name
+            entity=DatabaseService, fqn=prefix_db_service_name
         )
         dialect = ConnectionTypeDialectMapper.dialect_of(
             database_service.serviceType.value
@@ -221,7 +228,7 @@ class MicrostrategySource(DashboardServiceSource):
                 for table in lineage_parser.source_tables:
                     table_entities = get_table_entities_from_query(
                         metadata=self.metadata,
-                        service_name=db_service_name,
+                        service_name=prefix_db_service_name,
                         database_name="*",
                         database_schema="*",
                         table_name=str(table),
@@ -230,6 +237,29 @@ class MicrostrategySource(DashboardServiceSource):
                         logger.debug(f"Table not found in metadata: {str(table)}")
                         continue
                     for table_entity in table_entities or []:
+                        if (
+                            prefix_table_name
+                            and prefix_table_name.lower()
+                            != str(table_entity.name.root).lower()
+                        ):
+                            continue
+
+                        if (
+                            prefix_schema_name
+                            and getattr(table_entity.databaseSchema, "name", None)
+                            and prefix_schema_name.lower()
+                            != str(table_entity.databaseSchema.name).lower()
+                        ):
+                            continue
+
+                        if (
+                            prefix_database_name
+                            and getattr(table_entity.database, "name", None)
+                            and prefix_database_name.lower()
+                            != str(table_entity.database.name).lower()
+                        ):
+                            continue
+
                         yield Either(
                             right=AddLineageRequest(
                                 edge=EntitiesEdge(

metadata/ingestion/source/dashboard/mode/metadata.py

@@ -110,9 +110,11 @@ class ModeSource(DashboardServiceSource):
             name=EntityName(dashboard_details.get(client.TOKEN)),
             sourceUrl=SourceUrl(dashboard_url),
             displayName=dashboard_details.get(client.NAME),
-            description=Markdown(dashboard_details.get(client.DESCRIPTION))
-            if dashboard_details.get(client.DESCRIPTION)
-            else None,
+            description=(
+                Markdown(dashboard_details.get(client.DESCRIPTION))
+                if dashboard_details.get(client.DESCRIPTION)
+                else None
+            ),
             charts=[
                 FullyQualifiedEntityName(
                     fqn.build(
@@ -130,51 +132,95 @@ class ModeSource(DashboardServiceSource):
         yield Either(right=dashboard_request)
         self.register_record(dashboard_request=dashboard_request)
 
+    # pylint: disable=too-many-locals
     def yield_dashboard_lineage_details(
         self,
         dashboard_details: dict,
-        db_service_name: Optional[str] = None,
+        db_service_prefix: Optional[str] = None,
     ) -> Iterable[Either[AddLineageRequest]]:
         """Get lineage method"""
+        (
+            prefix_service_name,
+            prefix_database_name,
+            prefix_schema_name,
+            prefix_table_name,
+        ) = self.parse_db_service_prefix(db_service_prefix)
+
         try:
             response_queries = self.client.get_all_queries(
                 workspace_name=self.workspace_name,
                 report_token=dashboard_details[client.TOKEN],
             )
             queries = response_queries[client.EMBEDDED][client.QUERIES]
+
             for query in queries:
                 if not query.get("data_source_id"):
                     continue
                 data_source = self.data_sources.get(query.get("data_source_id"))
                 if not data_source:
                     continue
+
+                database_name = data_source.get(client.DATABASE)
+                if (
+                    prefix_database_name
+                    and database_name
+                    and prefix_database_name.lower() != str(database_name).lower()
+                ):
+                    logger.debug(
+                        f"Database {database_name} does not match prefix {prefix_database_name}"
+                    )
+                    continue
+
                 lineage_parser = LineageParser(query.get("raw_query"))
                 for table in lineage_parser.source_tables:
                     database_schema_name, table = fqn.split(str(table))[-2:]
                     database_schema_name = self.check_database_schema_name(
                         database_schema_name
                     )
+
+                    if (
+                        prefix_table_name
+                        and table
+                        and prefix_table_name.lower() != str(table).lower()
+                    ):
+                        logger.debug(
+                            f"Table {table} does not match prefix {prefix_table_name}"
+                        )
+                        continue
+
+                    if (
+                        prefix_schema_name
+                        and database_schema_name
+                        and prefix_schema_name.lower()
+                        != str(database_schema_name).lower()
+                    ):
+                        logger.debug(
+                            f"Schema {database_schema_name} does not match prefix {prefix_schema_name}"
+                        )
+                        continue
+
                     fqn_search_string = build_es_fqn_search_string(
-                        database_name=data_source.get(client.DATABASE),
-                        schema_name=database_schema_name,
-                        service_name=db_service_name or "*",
-                        table_name=table,
+                        database_name=prefix_database_name or database_name,
+                        schema_name=prefix_schema_name or database_schema_name,
+                        service_name=prefix_service_name or "*",
+                        table_name=prefix_table_name or table,
                     )
                     from_entities = self.metadata.search_in_any_service(
                         entity_type=Table,
                         fqn_search_string=fqn_search_string,
                         fetch_multiple_entities=True,
                     )
+
+                    to_entity = self.metadata.get_by_name(
+                        entity=Lineage_Dashboard,
+                        fqn=fqn.build(
+                            self.metadata,
+                            Lineage_Dashboard,
+                            service_name=self.config.serviceName,
+                            dashboard_name=dashboard_details.get(client.TOKEN),
+                        ),
+                    )
                     for from_entity in from_entities or []:
-                        to_entity = self.metadata.get_by_name(
-                            entity=Lineage_Dashboard,
-                            fqn=fqn.build(
-                                self.metadata,
-                                Lineage_Dashboard,
-                                service_name=self.config.serviceName,
-                                dashboard_name=dashboard_details.get(client.TOKEN),
-                            ),
-                        )
                         yield self._get_add_lineage_request(
                             to_entity=to_entity, from_entity=from_entity
                         )
@@ -182,7 +228,7 @@ class ModeSource(DashboardServiceSource):
             yield Either(
                 left=StackTraceError(
                     name="Lineage",
-                    error=f"Error to yield dashboard lineage details for DB service name [{db_service_name}]: {exc}",
+                    error=f"Error to yield dashboard lineage details for service name [{prefix_service_name}]: {exc}",
                     stackTrace=traceback.format_exc(),
                 )
             )

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

@@ -164,6 +164,10 @@ class PowerBiApiClient:
             List[PowerBIDashboard]
         """
         if self.config.useAdminApis:
+            logger.debug(
+                f"Calling the API({str(self.client._base_url)}/myorg/admin/dashboards)"  # pylint: disable=protected-access
+                " to get dashboards"
+            )
             response_data = self.client.get("/myorg/admin/dashboards")
             response = DashboardsResponse(**response_data)
             return response.value
@@ -178,6 +182,10 @@ class PowerBiApiClient:
             List[PowerBIDashboard]
         """
         try:
+            logger.debug(
+                f"Calling the API({str(self.client._base_url)}/myorg/groups/{group_id}/dashboards)"  # pylint: disable=protected-access
+                " to get group dashboards"
+            )
             response_data = self.client.get(f"/myorg/groups/{group_id}/dashboards")
             response = DashboardsResponse(**response_data)
             return response.value
@@ -193,6 +201,10 @@ class PowerBiApiClient:
             List[PowerBIReport]
         """
         try:
+            logger.debug(
+                f"Calling the API({str(self.client._base_url)}/myorg/groups/{group_id}/reports)"  # pylint: disable=protected-access
+                " to get group reports"
+            )
             response_data = self.client.get(f"/myorg/groups/{group_id}/reports")
             response = ReportsResponse(**response_data)
             return response.value
@@ -208,6 +220,10 @@ class PowerBiApiClient:
             List[Dataset]
         """
         try:
+            logger.debug(
+                f"Calling the API({str(self.client._base_url)}/myorg/groups/{group_id}/datasets)"  # pylint: disable=protected-access
+                " to get group datasets"
+            )
             response_data = self.client.get(f"/myorg/groups/{group_id}/datasets")
             response = DatasetResponse(**response_data)
             return response.value
@@ -225,6 +241,10 @@ class PowerBiApiClient:
             List[Tile]
         """
         try:
+            logger.debug(
+                f"Calling the API({str(self.client._base_url)}/myorg/groups/{group_id}/dashboards/{dashboard_id}/tiles)"  # pylint: disable=protected-access
+                " to get dashboard tiles"
+            )
             response_data = self.client.get(
                 f"/myorg/groups/{group_id}/dashboards/{dashboard_id}/tiles"
             )
@@ -244,6 +264,10 @@ class PowerBiApiClient:
             List[PowerBiTable]
         """
         try:
+            logger.debug(
+                f"Calling the API({str(self.client._base_url)}/myorg/groups/{group_id}/datasets/{dataset_id}/tables)"  # pylint: disable=protected-access
+                " to get dataset tables"
+            )
             response_data = self.client.get(
                 f"/myorg/groups/{group_id}/datasets/{dataset_id}/tables"
             )
@@ -357,6 +381,11 @@ class PowerBiApiClient:
             params_data = deepcopy(GETGROUPS_DEFAULT_PARAMS)
             if parsed_filter_query:
                 params_data["$filter"] = parsed_filter_query
+            logger.debug(
+                f"Calling the API({str(self.client._base_url)}/myorg/{admin}groups)"  # pylint: disable=protected-access
+                " to get workspaces(initial call to get count of workspaces and then"
+                " further paginate all workspace calls)"
+            )
             response = self.client.get(api_url, data=params_data)
             if (
                 not response
@@ -391,17 +420,20 @@ class PowerBiApiClient:
                 }
                 if parsed_filter_query:
                     params_data["$filter"] = parsed_filter_query
-
+                index_range = (
+                    int(params_data.get("$skip")),
+                    int(params_data.get("$skip")) + int(params_data.get("$top")),
+                )
+                logger.debug(
+                    f"Calling the API({str(self.client._base_url)}/myorg/{admin}groups)"  # pylint: disable=protected-access
+                    f" to get workspaces between results: {str(index_range)}"
+                )
                 response = self.client.get(api_url, data=params_data)
                 if (
                     not response
                     or API_RESPONSE_MESSAGE_KEY in response
                     or len(response) != len(GroupsResponse.__annotations__)
                 ):
-                    index_range = (
-                        int(params_data.get("$skip")),
-                        int(params_data.get("$skip")) + int(params_data.get("$top")),
-                    )
                     logger.warning(
                         f"Error fetching workspaces between results: {str(index_range)}"
                     )
@@ -423,17 +455,20 @@ class PowerBiApiClient:
                     "Retrying one more time on failed indexes to get workspaces"
                 )
                 for params_data in failed_indexes:
+                    index_range = (
+                        int(params_data.get("$skip")),
+                        int(params_data.get("$skip")) + int(params_data.get("$top")),
+                    )
+                    logger.debug(
+                        f"Calling the API({str(self.client._base_url)}/myorg/{admin}groups)"  # pylint: disable=protected-access
+                        f" to get workspaces between results: {str(index_range)}"
+                    )
                     response = self.client.get(api_url, data=params_data)
                     if (
                         not response
                         or API_RESPONSE_MESSAGE_KEY in response
                         or len(response) != len(GroupsResponse.__annotations__)
                     ):
-                        index_range = (
-                            int(params_data.get("$skip")),
-                            int(params_data.get("$skip"))
-                            + int(params_data.get("$top")),
-                        )
                         logger.warning(
                             f"Workspaces between results {str(index_range)} "
                             "could not be fetched on multiple attempts"
@@ -471,6 +506,10 @@ class PowerBiApiClient:
                 "datasetExpressions=True&datasetSchema=True"
                 "&datasourceDetails=True&getArtifactUsers=True&lineage=True"
             )
+            logger.debug(
+                f"Calling the API({str(self.client._base_url)}{path})"  # pylint: disable=protected-access
+                " to initiate workspace scan"
+            )
             response_data = self.client.post(path=path, data=data)
             return WorkSpaceScanResponse(**response_data)
         except Exception as exc:  # pylint: disable=broad-except
@@ -489,6 +528,10 @@ class PowerBiApiClient:
             WorkSpaceScanResponse
         """
         try:
+            logger.debug(
+                f"Calling the API({str(self.client._base_url)}/myorg/admin/workspaces/scanStatus/{scan_id})"  # pylint: disable=protected-access
+                " to get workspace scan status"
+            )
             response_data = self.client.get(
                 f"/myorg/admin/workspaces/scanStatus/{scan_id}"
             )
@@ -507,6 +550,10 @@ class PowerBiApiClient:
             Workspaces
         """
         try:
+            logger.debug(
+                f"Calling the API({str(self.client._base_url)}/myorg/admin/workspaces/scanResult/{scan_id})"  # pylint: disable=protected-access
+                " to get workspace scan result"
+            )
             response_data = self.client.get(
                 f"/myorg/admin/workspaces/scanResult/{scan_id}"
             )

metadata/ingestion/source/dashboard/powerbi/metadata.py

@@ -466,9 +466,9 @@ class PowerbiSource(DashboardServiceSource):
         for column in table.columns or []:
             try:
                 parsed_column = {
-                    "dataTypeDisplay": column.dataType
-                    if column.dataType
-                    else DataType.UNKNOWN.value,
+                    "dataTypeDisplay": (
+                        column.dataType if column.dataType else DataType.UNKNOWN.value
+                    ),
                     "dataType": ColumnTypeParser.get_column_type(
                         column.dataType if column.dataType else None
                     ),
@@ -489,11 +489,20 @@ class PowerbiSource(DashboardServiceSource):
         datasource_columns = []
         for table in dataset.tables or []:
             try:
+                table_display_name = None
+                if self.service_connection.displayTableNameFromSource:
+                    table_display_name = self.parse_table_name_from_source(table=table)
+                    if table_display_name:
+                        logger.debug(
+                            f"Parsed Table display name: {table_display_name} for table: {table.name}"
+                        )
+                if not table_display_name:
+                    table_display_name = table.name
                 parsed_table = {
                     "dataTypeDisplay": "PowerBI Table",
                     "dataType": DataType.TABLE,
                     "name": table.name,
-                    "displayName": table.name,
+                    "displayName": table_display_name,
                     "description": table.description,
                     "children": [],
                 }
@@ -547,9 +556,11 @@ class PowerbiSource(DashboardServiceSource):
                     data_model_request = CreateDashboardDataModelRequest(
                         name=EntityName(dataset.id),
                         displayName=dataset.name,
-                        description=Markdown(dataset.description)
-                        if dataset.description
-                        else None,
+                        description=(
+                            Markdown(dataset.description)
+                            if dataset.description
+                            else None
+                        ),
                         service=FullyQualifiedEntityName(
                             self.context.get().dashboard_service
                         ),
@@ -615,11 +626,13 @@ class PowerbiSource(DashboardServiceSource):
 
     def create_datamodel_report_lineage(
         self,
+        db_service_prefix: Optional[str],
         dashboard_details: PowerBIReport,
     ) -> Iterable[Either[CreateDashboardRequest]]:
         """
         create the lineage between datamodel and report
         """
+
         try:
             report_fqn = fqn.build(
                 self.metadata,
@@ -683,6 +696,41 @@ class PowerbiSource(DashboardServiceSource):
             logger.debug(f"Error to get data_model_column_fqn {exc}")
             logger.debug(traceback.format_exc())
 
+    def parse_table_name_from_source(self, table: PowerBiTable) -> Optional[str]:
+        """
+        Parse the snowflake table name
+        """
+        try:
+            if not isinstance(table.source, list):
+                return None
+            source_expression = table.source[0].expression
+            if not source_expression:
+                logger.debug(f"No source expression found for table: {table.name}")
+                return None
+
+            if "Snowflake.Databases" in source_expression:
+                # snowflake expression
+                table_match = re.search(
+                    r'\[Name=(?:"([^"]+)"|([^,]+)),Kind="Table"\]', source_expression
+                )
+                view_match = re.search(
+                    r'\[Name=(?:"([^"]+)"|([^,]+)),Kind="View"\]', source_expression
+                )
+                table = table_match.group(1) if table_match else None
+                view = view_match.group(1) if view_match else None
+                return table if table else view
+
+            # other general expressions
+            table_match = re.findall(r'\[Name="([^"]+)"\]', source_expression)
+            table = None
+            if isinstance(table_match, list):
+                table = table_match[1] if len(table_match) > 1 else None
+            return table
+        except Exception as exc:
+            logger.debug(f"Error to parse display table name: {exc}")
+            logger.debug(traceback.format_exc())
+        return None
+
     def _parse_snowflake_regex_exp(
         self, match: re.Match, datamodel_entity: DashboardDataModel
     ) -> Optional[str]:
@@ -802,20 +850,60 @@ class PowerbiSource(DashboardServiceSource):
 
     def _get_table_and_datamodel_lineage(
         self,
-        db_service_name: Optional[str],
+        db_service_prefix: Optional[str],
         table: PowerBiTable,
         datamodel_entity: DashboardDataModel,
     ) -> Iterable[Either[AddLineageRequest]]:
         """
         Method to create lineage between table and datamodels
         """
+        (
+            prefix_service_name,
+            prefix_database_name,
+            prefix_schema_name,
+            prefix_table_name,
+        ) = self.parse_db_service_prefix(db_service_prefix)
+
         try:
             table_info = self._parse_table_info_from_source_exp(table, datamodel_entity)
+            table_name = table.name or table_info.get("table")
+            schema_name = table_info.get("schema")
+            database_name = table_info.get("database")
+            if (
+                prefix_table_name
+                and table_name
+                and prefix_table_name.lower() != table_name.lower()
+            ):
+                logger.debug(
+                    f"Table {table_name} does not match prefix {prefix_table_name}"
+                )
+                return
+
+            if (
+                prefix_schema_name
+                and schema_name
+                and prefix_schema_name.lower() != schema_name.lower()
+            ):
+                logger.debug(
+                    f"Schema {table_info.get('schema')} does not match prefix {prefix_schema_name}"
+                )
+                return
+
+            if (
+                prefix_database_name
+                and database_name
+                and prefix_database_name.lower() != database_name.lower()
+            ):
+                logger.debug(
+                    f"Database {table_info.get('database')} does not match prefix {prefix_database_name}"
+                )
+                return
+
             fqn_search_string = build_es_fqn_search_string(
-                service_name=db_service_name or "*",
-                table_name=table_info.get("table") or table.name,
-                schema_name=table_info.get("schema") or "*",
-                database_name=table_info.get("database") or "*",
+                service_name=prefix_service_name or "*",
+                table_name=(prefix_table_name or table_name),
+                schema_name=(prefix_schema_name or schema_name),
+                database_name=(prefix_database_name or database_name),
             )
             table_entity = self.metadata.search_in_any_service(
                 entity_type=Table,
@@ -845,12 +933,14 @@ class PowerbiSource(DashboardServiceSource):
 
     def create_table_datamodel_lineage_from_files(
         self,
-        db_service_name: Optional[str],
+        db_service_prefix: Optional[str],
         datamodel_entity: Optional[DashboardDataModel],
     ) -> Iterable[Either[AddLineageRequest]]:
         """
         Method to create lineage between table and datamodels using pbit files
         """
+        (prefix_service_name, *_) = self.parse_db_service_prefix(db_service_prefix)
+
         try:
             # check if the datamodel_file_mappings is populated or not
             # if not, then populate the datamodel_file_mappings and process the lineage
@@ -871,7 +961,7 @@ class PowerbiSource(DashboardServiceSource):
             for datamodel_schema_file in datamodel_file_list:
                 for table in datamodel_schema_file.tables or []:
                     yield from self._get_table_and_datamodel_lineage(
-                        db_service_name=db_service_name,
+                        db_service_prefix=db_service_prefix,
                         table=table,
                         datamodel_entity=datamodel_entity,
                     )
@@ -881,7 +971,7 @@ class PowerbiSource(DashboardServiceSource):
                     name="DataModel Lineage",
                     error=(
                         "Error to yield datamodel lineage details for DB "
-                        f"service name [{str(db_service_name)}]: {exc}"
+                        f"service name [{prefix_service_name}]: {exc}"
                     ),
                     stackTrace=traceback.format_exc(),
                 )
@@ -1031,17 +1121,20 @@ class PowerbiSource(DashboardServiceSource):
     def yield_dashboard_lineage_details(
         self,
         dashboard_details: Group,
-        db_service_name: Optional[str] = None,
+        db_service_prefix: Optional[str] = None,
     ) -> Iterable[Either[AddLineageRequest]]:
         """
         We will build the logic to build the logic as below
         tables - datamodel - report - dashboard
         """
+        (prefix_service_name, *_) = self.parse_db_service_prefix(db_service_prefix)
+
         for dashboard in self.filtered_dashboards or []:
             dashboard_details = self.get_dashboard_details(dashboard)
             try:
                 if isinstance(dashboard_details, PowerBIReport):
                     yield from self.create_datamodel_report_lineage(
+                        db_service_prefix=db_service_prefix,
                         dashboard_details=dashboard_details,
                     )
                 if isinstance(dashboard_details, PowerBIDashboard):
@@ -1052,7 +1145,7 @@ class PowerbiSource(DashboardServiceSource):
                 yield Either(
                     left=StackTraceError(
                         name="Dashboard Lineage",
-                        error=f"Error to yield dashboard lineage details for DB service name [{str(db_service_name)}]: {exc}",
+                        error=f"Error to yield dashboard lineage details for DB service name [{str(prefix_service_name)}]: {exc}",
                         stackTrace=traceback.format_exc(),
                     )
                 )
@@ -1082,7 +1175,7 @@ class PowerbiSource(DashboardServiceSource):
                         # 1. datamodel-db_table lineage
                         for table in datamodel.tables or []:
                             yield from self._get_table_and_datamodel_lineage(
-                                db_service_name=db_service_name,
+                                db_service_prefix=db_service_prefix,
                                 table=table,
                                 datamodel_entity=datamodel_entity,
                             )
@@ -1097,7 +1190,7 @@ class PowerbiSource(DashboardServiceSource):
                         # create the lineage between table and datamodel using the pbit files
                         if self.client.file_client:
                             yield from self.create_table_datamodel_lineage_from_files(
-                                db_service_name=db_service_name,
+                                db_service_prefix=db_service_prefix,
                                 datamodel_entity=datamodel_entity,
                             )
                     elif isinstance(datamodel, Dataflow):
@@ -1113,7 +1206,7 @@ class PowerbiSource(DashboardServiceSource):
                 yield Either(
                     left=StackTraceError(
                         name="Datamodel Lineage",
-                        error=f"Error to yield datamodel lineage details for DB service name [{str(db_service_name)}]: {exc}",
+                        error=f"Error to yield datamodel lineage details for DB service name [{str(prefix_service_name)}]: {exc}",
                         stackTrace=traceback.format_exc(),
                     )
                 )

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

@@ -240,20 +240,35 @@ class QlikcloudSource(QliksenseSource):
         return None
 
     def yield_dashboard_lineage_details(
-        self,
-        dashboard_details: QlikApp,
-        db_service_name: Optional[str] = None,
+        self, dashboard_details: QlikApp, db_service_prefix: Optional[str] = None
     ) -> Iterable[Either[AddLineageRequest]]:
         """Get lineage method"""
+        (
+            prefix_service_name,
+            prefix_database_name,
+            prefix_schema_name,
+            prefix_table_name,
+        ) = self.parse_db_service_prefix(db_service_prefix)
         for datamodel in self.data_models or []:
             try:
                 data_model_entity = self._get_datamodel(datamodel_id=datamodel.id)
                 if data_model_entity:
+                    if (
+                        prefix_table_name
+                        and data_model_entity.displayName
+                        and prefix_table_name.lower()
+                        != data_model_entity.displayName.lower()
+                    ):
+                        logger.debug(
+                            f"Table {data_model_entity.displayName} does not match prefix {prefix_table_name}"
+                        )
+                        continue
+
                     fqn_search_string = build_es_fqn_search_string(
-                        database_name=None,
-                        schema_name=None,
-                        service_name=db_service_name or "*",
-                        table_name=data_model_entity.displayName,
+                        database_name=prefix_database_name,
+                        schema_name=prefix_schema_name,
+                        service_name=prefix_service_name or "*",
+                        table_name=prefix_table_name or data_model_entity.displayName,
                     )
                     om_table = self.metadata.search_in_any_service(
                         entity_type=Table,
@@ -275,7 +290,7 @@ class QlikcloudSource(QliksenseSource):
                         name=f"{dashboard_details.name} Lineage",
                         error=(
                             "Error to yield dashboard lineage details for DB "
-                            f"service name [{db_service_name}]: {err}"
+                            f"service name [{prefix_service_name}]: {err}"
                         ),
                         stackTrace=traceback.format_exc(),
                     )