openmetadata-ingestion 1.2.5.1__py3-none-any.whl → 1.3.0.0__py3-none-any.whl

metadata/profiler/interface/sqlalchemy/databricks/profiler_interface.py

@@ -0,0 +1,26 @@
+#  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.
+
+"""
+Interfaces with database for all database engine
+supporting sqlalchemy abstraction layer
+"""
+
+
+from metadata.profiler.interface.sqlalchemy.profiler_interface import (
+    SQAProfilerInterface,
+)
+
+
+class DatabricksProfilerInterface(SQAProfilerInterface):
+    def __init__(self, service_connection_config, **kwargs):
+        super().__init__(service_connection_config=service_connection_config, **kwargs)
+        self.set_catalog(self.session)

metadata/profiler/interface/sqlalchemy/db2/profiler_interface.py

@@ -0,0 +1,38 @@
+#  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.
+
+"""
+Interfaces with database for all database engine
+supporting sqlalchemy abstraction layer
+"""
+
+from metadata.profiler.interface.sqlalchemy.profiler_interface import (
+    SQAProfilerInterface,
+)
+from metadata.utils.logger import profiler_interface_registry_logger
+
+logger = profiler_interface_registry_logger()
+
+
+class DB2ProfilerInterface(SQAProfilerInterface):
+    """
+    Interface to interact with registry supporting
+    sqlalchemy.
+    """
+
+    def _programming_error_static_metric(self, runner, column, exc, session, metrics):
+        # pylint: disable=protected-access
+        if exc.orig and "overflow" in exc.orig._message:
+            logger.info(
+                f"Computing metrics without sum for {runner.table.__tablename__}.{column.name}"
+            )
+            return self._compute_static_metrics_wo_sum(metrics, runner, session, column)
+        return None

metadata/profiler/interface/sqlalchemy/mariadb/profiler_interface.py

@@ -0,0 +1,85 @@
+#  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.
+
+"""
+Interfaces with database for all database engine
+supporting sqlalchemy abstraction layer
+"""
+
+from typing import List
+
+from sqlalchemy.exc import ProgrammingError
+
+from metadata.profiler.interface.sqlalchemy.profiler_interface import (
+    SQAProfilerInterface,
+    handle_query_exception,
+)
+from metadata.profiler.metrics.registry import Metrics
+from metadata.profiler.processor.runner import QueryRunner
+from metadata.profiler.source.mariadb.metrics.window.first_quartile import (
+    MariaDBFirstQuartile,
+)
+from metadata.profiler.source.mariadb.metrics.window.median import MariaDBMedian
+from metadata.profiler.source.mariadb.metrics.window.third_quartile import (
+    MariaDBThirdQuartile,
+)
+from metadata.utils.logger import profiler_interface_registry_logger
+
+logger = profiler_interface_registry_logger()
+
+
+class MariaDBProfilerInterface(SQAProfilerInterface):
+    """
+    Interface to interact with registry supporting
+    sqlalchemy.
+    """
+
+    def _compute_window_metrics(
+        self,
+        metrics: List[Metrics],
+        runner: QueryRunner,
+        *args,
+        **kwargs,
+    ):
+        """Given a list of metrics, compute the given results
+        and returns the values
+
+        Args:
+            column: the column to compute the metrics against
+            metrics: list of metrics to compute
+        Returns:
+            dictionnary of results
+        """
+        session = kwargs.get("session")
+        column = kwargs.get("column")
+
+        if not metrics:
+            return None
+
+        try:
+            # we patch the metrics at runtime to use the MariaDB specific functions
+            # as we can't compile the query based on the dialect as it return `mysql`
+            metrics = [MariaDBFirstQuartile, MariaDBMedian, MariaDBThirdQuartile]  # type: ignore
+            row = runner.select_first_from_sample(
+                *[metric(column).fn() for metric in metrics],
+            )
+            if row:
+                return dict(row)
+        except ProgrammingError:
+            logger.info(
+                f"Skipping window metrics for {runner.table.__tablename__}.{column.name} due to overflow"
+            )
+            return None
+
+        except Exception as exc:
+            msg = f"Error trying to compute profile for {runner.table.__tablename__}.{column.name}: {exc}"
+            handle_query_exception(msg, exc, session)
+        return None

metadata/profiler/interface/sqlalchemy/profiler_interface.py

@@ -22,26 +22,27 @@ from collections import defaultdict
 from datetime import datetime, timezone
 from typing import Dict, List, Optional
 
-from sqlalchemy import Column, inspect
-from sqlalchemy.exc import ProgrammingError, ResourceClosedError
+from sqlalchemy import Column, inspect, text
+from sqlalchemy.exc import DBAPIError, ProgrammingError, ResourceClosedError
 from sqlalchemy.orm import scoped_session
 
-from metadata.generated.schema.entity.data.table import TableData
+from metadata.generated.schema.entity.data.table import CustomMetricProfile, TableData
+from metadata.generated.schema.tests.customMetric import CustomMetric
 from metadata.ingestion.connections.session import create_and_bind_thread_safe_session
 from metadata.mixins.sqalchemy.sqa_mixin import SQAInterfaceMixin
+from metadata.profiler.api.models import ThreadPoolMetrics
 from metadata.profiler.interface.profiler_interface import ProfilerInterface
 from metadata.profiler.metrics.core import MetricTypes
 from metadata.profiler.metrics.registry import Metrics
 from metadata.profiler.metrics.static.mean import Mean
 from metadata.profiler.metrics.static.stddev import StdDev
 from metadata.profiler.metrics.static.sum import Sum
-from metadata.profiler.orm.functions.table_metric_construct import (
-    table_metric_construct_factory,
-)
+from metadata.profiler.orm.functions.table_metric_computer import TableMetricComputer
 from metadata.profiler.orm.registry import Dialects
 from metadata.profiler.processor.runner import QueryRunner
 from metadata.utils.constants import SAMPLE_DATA_DEFAULT_COUNT
 from metadata.utils.custom_thread_pool import CustomThreadPoolExecutor
+from metadata.utils.helpers import is_safe_sql_query
 from metadata.utils.logger import profiler_interface_registry_logger
 
 logger = profiler_interface_registry_logger()
@@ -101,10 +102,11 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
         )
 
         self._table = self._convert_table_to_orm_object(sqa_metadata)
+        self.create_session()
+
+    def create_session(self):
         self.session_factory = self._session_factory()
         self.session = self.session_factory()
-        self.set_session_tag(self.session)
-        self.set_catalog(self.session)
 
     @property
     def table(self):
@@ -182,12 +184,13 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
         # pylint: disable=protected-access
         try:
             dialect = runner._session.get_bind().dialect.name
-            row = table_metric_construct_factory.construct(
+            table_metric_computer: TableMetricComputer = TableMetricComputer(
                 dialect,
                 runner=runner,
                 metrics=metrics,
                 conn_config=self.service_connection_config,
             )
+            row = table_metric_computer.compute()
             if row:
                 return dict(row)
             return None
@@ -227,7 +230,7 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
                 ],
             )
             return dict(row)
-        except ProgrammingError as exc:
+        except (ProgrammingError, DBAPIError) as exc:
             return self._programming_error_static_metric(
                 runner, column, exc, session, metrics
             )
@@ -307,6 +310,8 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
             row = runner.select_first_from_sample(
                 *[metric(column).fn() for metric in metrics],
             )
+            if row:
+                return dict(row)
         except ProgrammingError as exc:
             logger.info(
                 f"Skipping metrics for {runner.table.__tablename__}.{column.name} due to {exc}"
@@ -314,8 +319,43 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
         except Exception as exc:
             msg = f"Error trying to compute profile for {runner.table.__tablename__}.{column.name}: {exc}"
             handle_query_exception(msg, exc, session)
-        if row:
-            return dict(row)
+        return None
+
+    def _compute_custom_metrics(
+        self, metrics: List[CustomMetric], runner, session, *args, **kwargs
+    ):
+        """Compute custom metrics
+
+        Args:
+            metrics (List[Metrics]): list of customMetrics
+            runner (_type_): runner
+        """
+        if not metrics:
+            return None
+
+        custom_metrics = []
+
+        for metric in metrics:
+            try:
+                if not is_safe_sql_query(metric.expression):
+                    raise RuntimeError(
+                        f"SQL expression is not safe\n\n{metric.expression}"
+                    )
+
+                crs = session.execute(text(metric.expression))
+                row = (
+                    crs.scalar()
+                )  # raise MultipleResultsFound if more than one row is returned
+                custom_metrics.append(
+                    CustomMetricProfile(name=metric.name.__root__, value=row)
+                )
+
+            except Exception as exc:
+                msg = f"Error trying to compute profile for {runner.table.__tablename__}.{metric.columnName}: {exc}"
+                logger.debug(traceback.format_exc())
+                logger.warning(msg)
+        if custom_metrics:
+            return {"customMetrics": custom_metrics}
         return None
 
     def _compute_system_metrics(
@@ -372,18 +412,17 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
                 partition_details=self.partition_details,
                 profile_sample_query=self.profile_query,
             )
+            return thread_local.runner
+        thread_local.runner._sample = sample  # pylint: disable=protected-access
         return thread_local.runner
 
     def compute_metrics_in_thread(
         self,
-        metrics,
-        metric_type,
-        column,
-        table,
+        metric_func: ThreadPoolMetrics,
     ):
         """Run metrics in processor worker"""
         logger.debug(
-            f"Running profiler for {table.__tablename__} on thread {threading.current_thread()}"
+            f"Running profiler for {metric_func.table.__tablename__} on thread {threading.current_thread()}"
         )
         Session = self.session_factory  # pylint: disable=invalid-name
         with Session() as session:
@@ -391,36 +430,40 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
             self.set_catalog(session)
             sampler = self._create_thread_safe_sampler(
                 session,
-                table,
+                metric_func.table,
             )
-            sample = sampler.random_sample()
+            sample = sampler.random_sample(metric_func.column)
             runner = self._create_thread_safe_runner(
                 session,
-                table,
+                metric_func.table,
                 sample,
             )
             row = None
 
             try:
-                row = self._get_metric_fn[metric_type.value](
-                    metrics,
+                row = self._get_metric_fn[metric_func.metric_type.value](
+                    metric_func.metrics,
                     runner=runner,
                     session=session,
-                    column=column,
+                    column=metric_func.column,
                     sample=sample,
                 )
             except Exception as exc:
-                error = f"{column if column is not None else runner.table.__tablename__} metric_type.value: {exc}"
+                error = (
+                    f"{metric_func.column if metric_func.column is not None else metric_func.table.__tablename__} "
+                    f"metric_type.value: {exc}"
+                )
                 logger.error(error)
                 self.status.failed_profiler(error, traceback.format_exc())
 
-            if column is not None:
-                column = column.name
-                self.status.scanned(f"{table.__tablename__}.{column}")
+            if metric_func.column is not None:
+                column = metric_func.column.name
+                self.status.scanned(f"{metric_func.table.__tablename__}.{column}")
             else:
-                self.status.scanned(table.__tablename__)
+                self.status.scanned(metric_func.table.__tablename__)
+                column = None
 
-            return row, column, metric_type.value
+            return row, column, metric_func.metric_type.value
 
     # pylint: disable=use-dict-literal
     def get_all_metrics(
@@ -434,7 +477,7 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
             futures = [
                 pool.submit(
                     self.compute_metrics_in_thread,
-                    *metric_func,
+                    metric_func,
                 )
                 for metric_func in metric_funcs
             ]
@@ -455,6 +498,8 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
                         profile_results["table"].update(profile)
                     elif metric_type == MetricTypes.System.value:
                         profile_results["system"] = profile
+                    elif metric_type == MetricTypes.Custom.value and column is None:
+                        profile_results["table"].update(profile)
                     else:
                         profile_results["columns"][column].update(
                             {
@@ -521,7 +566,7 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
             dictionnary of results
         """
         sampler = self._get_sampler(table=kwargs.get("table"))
-        sample = sampler.random_sample()
+        sample = sampler.random_sample(column)
         try:
             return metric(column).fn(sample, column_results, self.session)
         except Exception as exc:
@@ -534,9 +579,7 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
         """
         Override Programming Error for Static Metrics
         """
-        logger.error(
-            f"Skipping metrics due to {exc} for {runner.table.__tablename__}.{column.name}"
-        )
+        raise exc
 
     def get_columns(self):
         """get columns from entity"""

metadata/profiler/interface/sqlalchemy/single_store/profiler_interface.py

@@ -72,6 +72,8 @@ class SingleStoreProfilerInterface(SQAProfilerInterface):
             row = runner.select_first_from_sample(
                 *[metric(column).fn() for metric in metrics],
             )
+            if row:
+                return dict(row)
         except ProgrammingError:
             logger.info(
                 f"Skipping window metrics for {runner.table.__tablename__}.{column.name} due to overflow"
@@ -81,6 +83,4 @@ class SingleStoreProfilerInterface(SQAProfilerInterface):
         except Exception as exc:
             msg = f"Error trying to compute profile for {runner.table.__tablename__}.{column.name}: {exc}"
             handle_query_exception(msg, exc, session)
-        if row:
-            return dict(row)
         return None

metadata/profiler/interface/sqlalchemy/snowflake/profiler_interface.py

@@ -29,6 +29,13 @@ class SnowflakeProfilerInterface(SQAProfilerInterface):
     sqlalchemy.
     """
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def create_session(self):
+        super().create_session()
+        self.set_session_tag(self.session)
+
     def _programming_error_static_metric(self, runner, column, exc, session, metrics):
         if exc.orig and exc.orig.errno in OVERFLOW_ERROR_CODES.get(
             session.bind.dialect.name

metadata/profiler/interface/sqlalchemy/trino/profiler_interface.py

@@ -67,6 +67,8 @@ class TrinoProfilerInterface(SQAProfilerInterface):
             row = runner.select_first_from_sample(
                 *[metric(column).fn() for metric in metrics], **runner_kwargs
             )
+            if row:
+                return dict(row)
         except ProgrammingError as err:
             logger.info(
                 f"Skipping window metrics for {runner.table.__tablename__}.{column.name} due to {err}"
@@ -76,6 +78,4 @@ class TrinoProfilerInterface(SQAProfilerInterface):
         except Exception as exc:
             msg = f"Error trying to compute profile for {runner.table.__tablename__}.{column.name}: {exc}"
             handle_query_exception(msg, exc, session)
-        if row:
-            return dict(row)
         return None

metadata/profiler/interface/sqlalchemy/unity_catalog/profiler_interface.py

@@ -0,0 +1,33 @@
+#  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.
+
+"""
+Interfaces with database for all database engine
+supporting sqlalchemy abstraction layer
+"""
+
+
+from metadata.ingestion.source.database.databricks.connection import (
+    get_connection as databricks_get_connection,
+)
+from metadata.profiler.interface.sqlalchemy.profiler_interface import (
+    SQAProfilerInterface,
+)
+
+
+class UnityCatalogProfilerInterface(SQAProfilerInterface):
+    def __init__(self, service_connection_config, **kwargs):
+        super().__init__(service_connection_config=service_connection_config, **kwargs)
+
+    def create_session(self):
+        self.connection = databricks_get_connection(self.service_connection_config)
+        super().create_session()
+        self.set_catalog(self.session)

metadata/profiler/metrics/composed/null_ratio.py

@@ -51,7 +51,7 @@ class NullRatio(ComposedMetric):
         res_count = res.get(Count.name())
         res_null = res.get(NullCount.name())
 
-        if res_count and res_null is not None:
+        if res_count is not None and res_null is not None:
             return res_null / (res_null + res_count)
 
         return None

metadata/profiler/metrics/hybrid/histogram.py

@@ -30,6 +30,7 @@ from metadata.utils.logger import profiler_logger
 
 logger = profiler_logger()
 
+
 # pylint: disable=too-many-locals
 class Histogram(HybridMetric):
     """

metadata/profiler/metrics/static/max.py

@@ -90,6 +90,9 @@ class Max(StaticMetric):
 
     def df_fn(self, dfs=None):
         """pandas function"""
-        if is_quantifiable(self.col.type) or is_date_time(self.col.type):
+        if is_quantifiable(self.col.type):
             return max((df[self.col.name].max() for df in dfs))
+        if is_date_time(self.col.type):
+            max_ = max((df[self.col.name].max() for df in dfs))
+            return int(max_.timestamp() * 1000)
         return 0

metadata/profiler/metrics/static/min.py

@@ -90,6 +90,9 @@ class Min(StaticMetric):
 
     def df_fn(self, dfs=None):
         """pandas function"""
-        if is_quantifiable(self.col.type) or is_date_time(self.col.type):
+        if is_quantifiable(self.col.type):
             return min((df[self.col.name].min() for df in dfs))
+        if is_date_time(self.col.type):
+            min_ = min((df[self.col.name].min() for df in dfs))
+            return int(min_.timestamp() * 1000)
         return 0

metadata/profiler/metrics/system/queries/snowflake.py

@@ -15,10 +15,13 @@ Snowflake System Metric Queries and query operations
 
 import re
 import traceback
-from typing import Optional
+from typing import Optional, Tuple
 
 from sqlalchemy.engine.row import Row
 
+from metadata.generated.schema.entity.services.databaseService import DatabaseService
+from metadata.ingestion.lineage.sql_lineage import search_table_entities
+from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.utils.logger import profiler_logger
 from metadata.utils.profiler_utils import (
     SnowflakeQueryResult,
@@ -55,20 +58,92 @@ RESULT_SCAN = """
     """
 
 
+QUERY_PATTERN = r"(?:(INSERT\s*INTO\s*|INSERT\s*OVERWRITE\s*INTO\s*|UPDATE\s*|MERGE\s*INTO\s*|DELETE\s*FROM\s*))([\w._\"\'()]+)(?=[\s*\n])"  # pylint: disable=line-too-long
+IDENTIFIER_PATTERN = r"(IDENTIFIER\(\')([\w._\"]+)(\'\))"
+
+
+def _parse_query(query: str) -> Optional[str]:
+    """Parse snowflake queries to extract the identifiers"""
+    match = re.match(QUERY_PATTERN, query, re.IGNORECASE)
+    try:
+        # This will match results like `DATABASE.SCHEMA.TABLE1` or IDENTIFIER('TABLE1')
+        # If we have `IDENTIFIER` type of queries coming from Stored Procedures, we'll need to further clean it up.
+        identifier = match.group(2)
+
+        match_internal_identifier = re.match(
+            IDENTIFIER_PATTERN, identifier, re.IGNORECASE
+        )
+        internal_identifier = (
+            match_internal_identifier.group(2) if match_internal_identifier else None
+        )
+        if internal_identifier:
+            return internal_identifier
+
+        return identifier
+    except (IndexError, AttributeError):
+        logger.debug("Could not find identifier in query. Skipping row.")
+        return None
+
+
+def get_identifiers(
+    identifier: str, ometa_client: OpenMetadata, db_service: DatabaseService
+) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+    """Get query identifiers and if needed, fetch them from ES"""
+    database_name, schema_name, table_name = get_identifiers_from_string(identifier)
+
+    if not table_name:
+        logger.debug("Could not extract the table name. Skipping operation.")
+        return database_name, schema_name, table_name
+
+    if not all([database_name, schema_name]):
+        logger.debug(
+            "Missing database or schema info from the query. We'll look for it in ES."
+        )
+        es_tables = search_table_entities(
+            metadata=ometa_client,
+            service_name=db_service.fullyQualifiedName.__root__,
+            database=database_name,
+            database_schema=schema_name,
+            table=table_name,
+        )
+
+        if not es_tables:
+            logger.debug("No tables match the search criteria.")
+            return database_name, schema_name, table_name
+
+        if len(es_tables) > 1:
+            logger.debug(
+                "Found more than 1 table matching the search criteria."
+                " Skipping the computation to not mix system data."
+            )
+            return database_name, schema_name, table_name
+
+        matched_table = es_tables[0]
+        database_name = matched_table.database.name
+        schema_name = matched_table.databaseSchema.name
+
+    return database_name, schema_name, table_name
+
+
 def get_snowflake_system_queries(
-    row: Row, database: str, schema: str
+    row: Row,
+    database: str,
+    schema: str,
+    ometa_client: OpenMetadata,
+    db_service: DatabaseService,
 ) -> Optional[SnowflakeQueryResult]:
-    """get snowflake system queries for a specific database and schema. Parsing the query
-    is the only reliable way to get the DDL operation as fields in the table are not. If parsing
-    fails we'll fall back to regex lookup
+    """
+    Run a regex lookup on the query to identify which operation ran against the table.
 
-    1. Parse the query and check if we have an Identifier
-    2.
+    If the query does not have the complete set of `database.schema.table` when it runs,
+    we'll use ES to pick up the table, if we find it.
 
     Args:
         row (dict): row from the snowflake system queries table
         database (str): database name
         schema (str): schema name
+        ometa_client (OpenMetadata): OpenMetadata client to search against ES
+        db_service (DatabaseService): DB service where the process is running against
     Returns:
         QueryResult: namedtuple with the query result
     """
@@ -78,20 +153,17 @@ def get_snowflake_system_queries(
         query_text = dict_row.get("QUERY_TEXT", dict_row.get("query_text"))
         logger.debug(f"Trying to parse query:\n{query_text}\n")
 
-        pattern = r"(?:(INSERT\s*INTO\s*|INSERT\s*OVERWRITE\s*INTO\s*|UPDATE\s*|MERGE\s*INTO\s*|DELETE\s*FROM\s*))([\w._\"]+)(?=[\s*\n])"  # pylint: disable=line-too-long
-        match = re.match(pattern, query_text, re.IGNORECASE)
-        try:
-            identifier = match.group(2)
-        except (IndexError, AttributeError):
-            logger.debug("Could not find identifier in query. Skipping row.")
+        identifier = _parse_query(query_text)
+        if not identifier:
             return None
 
-        database_name, schema_name, table_name = get_identifiers_from_string(identifier)
+        database_name, schema_name, table_name = get_identifiers(
+            identifier=identifier,
+            ometa_client=ometa_client,
+            db_service=db_service,
+        )
 
         if not all([database_name, schema_name, table_name]):
-            logger.debug(
-                "Missing database, schema, or table. Can't link operation to table entity in OpenMetadata."
-            )
             return None
 
         if (