openmetadata-ingestion 1.2.4.0__py3-none-any.whl → 1.3.2.0rc1__py3-none-any.whl

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 (

metadata/profiler/metrics/system/system.py

@@ -23,6 +23,8 @@ from sqlalchemy.orm import DeclarativeMeta, Session
 from metadata.generated.schema.entity.services.connections.database.bigQueryConnection import (
     BigQueryConnection,
 )
+from metadata.generated.schema.entity.services.databaseService import DatabaseService
+from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.profiler.metrics.core import SystemMetric
 from metadata.profiler.metrics.system.dml_operation import (
     DML_OPERATION_MAP,
@@ -46,7 +48,11 @@ from metadata.profiler.orm.registry import Dialects
 from metadata.utils.dispatch import valuedispatch
 from metadata.utils.helpers import deep_size_of_dict
 from metadata.utils.logger import profiler_logger
-from metadata.utils.profiler_utils import get_value_from_cache, set_cache
+from metadata.utils.profiler_utils import (
+    SnowflakeQueryResult,
+    get_value_from_cache,
+    set_cache,
+)
 
 logger = profiler_logger()
 
@@ -285,11 +291,48 @@ def _(
     return metric_results
 
 
+def _snowflake_build_query_result(
+    session: Session,
+    table: DeclarativeMeta,
+    database: str,
+    schema: str,
+    ometa_client: OpenMetadata,
+    db_service: DatabaseService,
+) -> List[SnowflakeQueryResult]:
+    """List and parse snowflake DML query results"""
+    rows = session.execute(
+        text(
+            INFORMATION_SCHEMA_QUERY.format(
+                tablename=table.__tablename__,  # type: ignore
+                insert=DatabaseDMLOperations.INSERT.value,
+                update=DatabaseDMLOperations.UPDATE.value,
+                delete=DatabaseDMLOperations.DELETE.value,
+                merge=DatabaseDMLOperations.MERGE.value,
+            )
+        )
+    )
+    query_results = []
+    for row in rows:
+        result = get_snowflake_system_queries(
+            row=row,
+            database=database,
+            schema=schema,
+            ometa_client=ometa_client,
+            db_service=db_service,
+        )
+        if result:
+            query_results.append(result)
+
+    return query_results
+
+
 @get_system_metrics_for_dialect.register(Dialects.Snowflake)
 def _(
     dialect: str,
     session: Session,
     table: DeclarativeMeta,
+    ometa_client: OpenMetadata,
+    db_service: DatabaseService,
     *args,
     **kwargs,
 ) -> Optional[List[Dict]]:
@@ -315,22 +358,14 @@ def _(
 
     metric_results: List[Dict] = []
 
-    rows = session.execute(
-        text(
-            INFORMATION_SCHEMA_QUERY.format(
-                tablename=table.__tablename__,  # type: ignore
-                insert=DatabaseDMLOperations.INSERT.value,
-                update=DatabaseDMLOperations.UPDATE.value,
-                delete=DatabaseDMLOperations.DELETE.value,
-                merge=DatabaseDMLOperations.MERGE.value,
-            )
-        )
+    query_results = _snowflake_build_query_result(
+        session=session,
+        table=table,
+        database=database,
+        schema=schema,
+        ometa_client=ometa_client,
+        db_service=db_service,
     )
-    query_results = []
-    for row in rows:
-        result = get_snowflake_system_queries(row, database, schema)
-        if result:
-            query_results.append(result)
 
     for query_result in query_results:
         rows_affected = None
@@ -409,12 +444,17 @@ class System(SystemMetric):
             logger.debug("Clearing system cache")
             SYSTEM_QUERY_RESULT_CACHE.clear()
 
+    def _validate_attrs(self, attr_list: List[str]) -> None:
+        """Validate the necessary attributes given via add_props"""
+        for attr in attr_list:
+            if not hasattr(self, attr):
+                raise AttributeError(
+                    f"System requires a table to be set: add_props({attr}=...)(Metrics.SYSTEM.value)"
+                )
+
     def sql(self, session: Session, **kwargs):
         """Implements the SQL logic to fetch system data"""
-        if not hasattr(self, "table"):
-            raise AttributeError(
-                "System requires a table to be set: add_props(table=...)(Metrics.COLUMN_COUNT)"
-            )
+        self._validate_attrs(["table", "ometa_client", "db_service"])
 
         conn_config = kwargs.get("conn_config")
 
@@ -423,6 +463,8 @@ class System(SystemMetric):
             session=session,
             table=self.table,  # pylint: disable=no-member
             conn_config=conn_config,
+            ometa_client=self.ometa_client,  # pylint: disable=no-member
+            db_service=self.db_service,  # pylint: disable=no-member
         )
         self._manage_cache()
         return system_metrics

metadata/profiler/orm/functions/conn_test.py

@@ -48,6 +48,7 @@ def _(*_, **__):
 
 @compiles(ConnTestFn, Dialects.Db2)
 @compiles(ConnTestFn, Dialects.IbmDbSa)
+@compiles(ConnTestFn, Dialects.Ibmi)
 def _(*_, **__):
     return "SELECT 42 FROM SYSIBM.SYSDUMMY1;"
 

metadata/profiler/orm/functions/length.py

@@ -50,6 +50,7 @@ def _(element, compiler, **kw):
 @compiles(LenFn, Dialects.Db2)
 @compiles(LenFn, Dialects.Hana)
 @compiles(LenFn, Dialects.Druid)
+@compiles(LenFn, Dialects.Doris)
 def _(element, compiler, **kw):
     return "LENGTH(%s)" % compiler.process(element.clauses, **kw)
 

metadata/profiler/orm/functions/median.py

@@ -84,9 +84,10 @@ def _(elements, compiler, **kwargs):
     )
 
 
+@compiles(MedianFn, Dialects.Vertica)
 @compiles(MedianFn, Dialects.MSSQL)
 def _(elements, compiler, **kwargs):
-    """Median computation for MSSQL"""
+    """Median computation for MSSQL & Vertica"""
     col = compiler.process(elements.clauses.clauses[0])
     percentile = elements.clauses.clauses[2].value
     return "percentile_cont(%.2f) WITHIN GROUP (ORDER BY %s ASC) OVER()" % (
@@ -185,3 +186,10 @@ def _(elements, compiler, **kwargs):  # pylint: disable=unused-argument
     """.format(
         col=col, table=table, percentile=percentile
     )
+
+
+@compiles(MedianFn, Dialects.Doris)
+def _(elements, compiler, **kwargs):
+    col = compiler.process(elements.clauses.clauses[0])
+    percentile = elements.clauses.clauses[2].value
+    return "percentile_approx(%s, %.2f)" % (col, percentile)