openmetadata-ingestion 1.5.13.2__py3-none-any.whl → 1.6.0.0__py3-none-any.whl

metadata/data_quality/interface/pandas/pandas_test_suite_interface.py

@@ -14,9 +14,9 @@ Interfaces with database for all database engine
 supporting sqlalchemy abstraction layer
 """
 
-from metadata.data_quality.builders.i_validator_builder import IValidatorBuilder
-from metadata.data_quality.builders.pandas_validator_builder import (
-    PandasValidatorBuilder,
+from metadata.data_quality.builders.validator_builder import (
+    SourceType,
+    ValidatorBuilder,
 )
 from metadata.data_quality.interface.test_suite_interface import TestSuiteInterface
 from metadata.generated.schema.entity.data.table import Table
@@ -25,8 +25,8 @@ from metadata.generated.schema.entity.services.connections.database.datalakeConn
 )
 from metadata.generated.schema.tests.testCase import TestCase
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
-from metadata.ingestion.source.connections import get_connection
 from metadata.mixins.pandas.pandas_mixin import PandasInterfaceMixin
+from metadata.sampler.sampler_interface import SamplerInterface
 from metadata.utils.logger import test_suite_logger
 
 logger = test_suite_logger()
@@ -43,31 +43,32 @@ class PandasTestSuiteInterface(TestSuiteInterface, PandasInterfaceMixin):
         self,
         service_connection_config: DatalakeConnection,
         ometa_client: OpenMetadata,
-        table_entity: Table = None,
-        **kwargs,  # pylint: disable=unused-argument
+        sampler: SamplerInterface,
+        table_entity: Table,
+        **kwargs,
     ):
-        self.table_entity = table_entity
-
-        self.ometa_client = ometa_client
-        self.service_connection_config = service_connection_config
+        super().__init__(
+            service_connection_config,
+            ometa_client,
+            sampler,
+            table_entity,
+            **kwargs,
+        )
 
         (
-            self.table_sample_query,
-            self.table_sample_config,
-            self.table_partition_config,
+            self.sample_query,
+            self.profile_sample_config,
+            self.partition_details,
         ) = self._get_table_config()
 
-        # add partition logic to test suite
-        self.dfs = self.return_ometa_dataframes_sampled(
-            service_connection_config=self.service_connection_config,
-            client=get_connection(self.service_connection_config).client._client,
-            table=self.table_entity,
-            profile_sample_config=self.table_sample_config,
-        )
-        if self.dfs and self.table_partition_config:
-            self.dfs = self.get_partitioned_df(self.dfs)
+        self.dataset = self.sampler.get_dataset()
 
     def _get_validator_builder(
         self, test_case: TestCase, entity_type: str
-    ) -> IValidatorBuilder:
-        return PandasValidatorBuilder(self.dfs, test_case, entity_type)
+    ) -> ValidatorBuilder:
+        return self.validator_builder_class(
+            runner=self.dataset,
+            test_case=test_case,
+            entity_type=entity_type,
+            source_type=SourceType.PANDAS,
+        )

metadata/data_quality/interface/sqlalchemy/sqa_test_suite_interface.py

@@ -19,8 +19,10 @@ from typing import Union
 from sqlalchemy.orm import DeclarativeMeta
 from sqlalchemy.orm.util import AliasedClass
 
-from metadata.data_quality.builders.i_validator_builder import IValidatorBuilder
-from metadata.data_quality.builders.sqa_validator_builder import SQAValidatorBuilder
+from metadata.data_quality.builders.validator_builder import (
+    SourceType,
+    ValidatorBuilder,
+)
 from metadata.data_quality.interface.test_suite_interface import TestSuiteInterface
 from metadata.generated.schema.entity.data.table import Table
 from metadata.generated.schema.entity.services.databaseService import DatabaseConnection
@@ -29,7 +31,7 @@ from metadata.ingestion.connections.session import create_and_bind_session
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.mixins.sqalchemy.sqa_mixin import SQAInterfaceMixin
 from metadata.profiler.processor.runner import QueryRunner
-from metadata.profiler.processor.sampler.sqlalchemy.sampler import SQASampler
+from metadata.sampler.sampler_interface import SamplerInterface
 from metadata.utils.constants import TEN_MIN
 from metadata.utils.logger import test_suite_logger
 from metadata.utils.ssl_manager import get_ssl_connection
@@ -49,14 +51,15 @@ class SQATestSuiteInterface(SQAInterfaceMixin, TestSuiteInterface):
         self,
         service_connection_config: DatabaseConnection,
         ometa_client: OpenMetadata,
+        sampler: SamplerInterface,
         table_entity: Table = None,
-        sqa_metadata=None,
+        **kwargs,
     ):
-        self.ometa_client = ometa_client
-        self.table_entity = table_entity
-        self.service_connection_config = service_connection_config
+        super().__init__(
+            service_connection_config, ometa_client, sampler, table_entity, **kwargs
+        )
+        self.source_type = SourceType.SQL
         self.create_session()
-        self._table = self._convert_table_to_orm_object(sqa_metadata)
 
         (
             self.table_sample_query,
@@ -64,7 +67,6 @@ class SQATestSuiteInterface(SQAInterfaceMixin, TestSuiteInterface):
             self.table_partition_config,
         ) = self._get_table_config()
 
-        self._sampler = self._create_sampler()
         self._runner = self._create_runner()
 
     def create_session(self):
@@ -73,7 +75,7 @@ class SQATestSuiteInterface(SQAInterfaceMixin, TestSuiteInterface):
         )
 
     @property
-    def sample(self) -> Union[DeclarativeMeta, AliasedClass]:
+    def dataset(self) -> Union[DeclarativeMeta, AliasedClass]:
         """_summary_
 
         Returns:
@@ -84,7 +86,7 @@ class SQATestSuiteInterface(SQAInterfaceMixin, TestSuiteInterface):
                 "You must create a sampler first `<instance>.create_sampler(...)`."
             )
 
-        return self.sampler.random_sample()
+        return self.sampler.get_dataset()
 
     @property
     def runner(self) -> QueryRunner:
@@ -95,47 +97,14 @@ class SQATestSuiteInterface(SQAInterfaceMixin, TestSuiteInterface):
         """
         return self._runner
 
-    @property
-    def sampler(self) -> SQASampler:
-        """getter method for the Runner object
-
-        Returns:
-            Sampler: sampler object
-        """
-        return self._sampler
-
-    @property
-    def table(self):
-        """getter method for the table object
-
-        Returns:
-            Table: table object
-        """
-        return self._table
-
-    def _create_sampler(self) -> SQASampler:
-        """Create sampler instance"""
-        from metadata.profiler.processor.sampler.sampler_factory import (  # pylint: disable=import-outside-toplevel
-            sampler_factory_,
-        )
-
-        return sampler_factory_.create(
-            self.service_connection_config.__class__.__name__,
-            client=self.session,
-            table=self.table,
-            profile_sample_config=self.table_sample_config,
-            partition_details=self.table_partition_config,
-            profile_sample_query=self.table_sample_query,
-        )
-
-    def _create_runner(self) -> None:
+    def _create_runner(self) -> QueryRunner:
         """Create a QueryRunner Instance"""
 
         return cls_timeout(TEN_MIN)(
             QueryRunner(
                 session=self.session,
-                table=self.table,
-                sample=self.sample,
+                dataset=self.dataset,
+                raw_dataset=self.sampler.raw_dataset,
                 partition_details=self.table_partition_config,
                 profile_sample_query=self.table_sample_query,
             )
@@ -143,5 +112,10 @@ class SQATestSuiteInterface(SQAInterfaceMixin, TestSuiteInterface):
 
     def _get_validator_builder(
         self, test_case: TestCase, entity_type: str
-    ) -> IValidatorBuilder:
-        return SQAValidatorBuilder(self.runner, test_case, entity_type)
+    ) -> ValidatorBuilder:
+        return self.validator_builder_class(
+            runner=self.runner,
+            test_case=test_case,
+            entity_type=entity_type,
+            source_type=self.source_type,
+        )

metadata/data_quality/interface/test_suite_interface.py

@@ -15,9 +15,9 @@ supporting sqlalchemy abstraction layer
 """
 
 from abc import ABC, abstractmethod
-from typing import Optional, Type
+from typing import Optional, Set, Type
 
-from metadata.data_quality.builders.i_validator_builder import IValidatorBuilder
+from metadata.data_quality.builders.validator_builder import ValidatorBuilder
 from metadata.data_quality.validations.base_test_handler import BaseTestValidator
 from metadata.data_quality.validations.runtime_param_setter.param_setter import (
     RuntimeParameterSetter,
@@ -31,9 +31,8 @@ from metadata.generated.schema.tests.basic import TestCaseResult
 from metadata.generated.schema.tests.testCase import TestCase
 from metadata.generated.schema.tests.testDefinition import TestDefinition
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
-from metadata.profiler.api.models import ProfileSampleConfig
+from metadata.sampler.sampler_interface import SamplerInterface
 from metadata.utils.logger import test_suite_logger
-from metadata.utils.partition import get_partition_details
 
 logger = test_suite_logger()
 
@@ -43,32 +42,44 @@ class TestSuiteInterface(ABC):
 
     runtime_params_setter_fact = RuntimeParameterSetterFactory
 
-    @abstractmethod
     def __init__(
         self,
-        ometa_client: OpenMetadata,
         service_connection_config: DatabaseConnection,
+        ometa_client: OpenMetadata,
+        sampler: SamplerInterface,
         table_entity: Table,
+        validator_builder: Type[ValidatorBuilder],
     ):
         """Required attribute for the interface"""
         self.ometa_client = ometa_client
         self.service_connection_config = service_connection_config
         self.table_entity = table_entity
+        self.sampler = sampler
+        self.validator_builder_class = validator_builder
 
-    @property
-    def sampler(self):
-        """Get the sampler object
-
-        Note: Overriden in the implementation class. This should be removed from the interface. It has been
-        implemented as the RuntimeParameterSetter takes the sampler as an argument, though we may want to
-        remove that dependency.
-        """
-        return None
+    @classmethod
+    def create(
+        cls,
+        service_connection_config: DatabaseConnection,
+        ometa_client: OpenMetadata,
+        sampler: SamplerInterface,
+        table_entity: Table,
+        *args,
+        **kwargs,
+    ):
+        return cls(
+            service_connection_config,
+            ometa_client,
+            sampler,
+            table_entity,
+            *args,
+            **kwargs,
+        )
 
     @abstractmethod
     def _get_validator_builder(
         self, test_case: TestCase, entity_type: str
-    ) -> IValidatorBuilder:
+    ) -> ValidatorBuilder:
         """get the builder class for the validator. Define this in the implementation class
 
         Args:
@@ -76,7 +87,7 @@ class TestSuiteInterface(ABC):
             entity_type (str): type of the entity
 
         Returns:
-            IValidatorBuilder: a validator builder
+            ValidatorBuilder: a validator builder
         """
         raise NotImplementedError
 
@@ -102,9 +113,9 @@ class TestSuiteInterface(ABC):
         runtime_params_setter_fact: RuntimeParameterSetterFactory = (
             self._get_runtime_params_setter_fact()
         )  # type: ignore
-        runtime_params_setter: Optional[
+        runtime_params_setters: Set[
             RuntimeParameterSetter
-        ] = runtime_params_setter_fact.get_runtime_param_setter(
+        ] = runtime_params_setter_fact.get_runtime_param_setters(
             test_case.testDefinition.fullyQualifiedName,  # type: ignore
             self.ometa_client,
             self.service_connection_config,
@@ -118,7 +129,7 @@ class TestSuiteInterface(ABC):
         ).entityType.value
 
         validator_builder = self._get_validator_builder(test_case, entity_type)
-        validator_builder.set_runtime_params(runtime_params_setter)
+        validator_builder.set_runtime_params(runtime_params_setters)
         validator: BaseTestValidator = validator_builder.validator
         try:
             return validator.run_validation()
@@ -128,37 +139,10 @@ class TestSuiteInterface(ABC):
             )
             raise RuntimeError(err)
 
-    def _get_sample_query(self) -> Optional[str]:
-        """Get the sampling query for the data quality tests
-
-        Args:
-            entity (Table): _description_
-        """
-        if self.table_entity.tableProfilerConfig:
-            return self.table_entity.tableProfilerConfig.profileQuery
-
-        return None
-
-    def _get_profile_sample(self) -> Optional[ProfileSampleConfig]:
-        try:
-            if self.table_entity.tableProfilerConfig.profileSample:
-                return ProfileSampleConfig(
-                    profile_sample=self.table_entity.tableProfilerConfig.profileSample,
-                    profile_sample_type=self.table_entity.tableProfilerConfig.profileSampleType,
-                )
-        except AttributeError:
-            # if tableProfilerConfig is None it will indicate that the table has not profiler config
-            # hence we can return None
-            return None
-        return None
-
     def _get_table_config(self):
         """Get the sampling configuration for the data quality tests"""
-        sample_query = self._get_sample_query()
-        sample_config = None
-        partition_config = None
-        if not sample_query:
-            sample_config = self._get_profile_sample()
-            partition_config = get_partition_details(self.table_entity)
-
-        return sample_query, sample_config, partition_config
+        return (
+            self.sampler.sample_query,
+            self.sampler.sample_config,
+            self.sampler.partition_details,
+        )

metadata/data_quality/processor/test_case_runner.py

@@ -23,10 +23,8 @@ from metadata.data_quality.api.models import (
     TestCaseResults,
     TestSuiteProcessorConfig,
 )
+from metadata.data_quality.runner.base_test_suite_source import BaseTestSuiteRunner
 from metadata.data_quality.runner.core import DataTestsRunner
-from metadata.data_quality.runner.test_suite_source_factory import (
-    test_suite_source_factory,
-)
 from metadata.generated.schema.api.tests.createTestCase import CreateTestCaseRequest
 from metadata.generated.schema.entity.data.table import Table
 from metadata.generated.schema.entity.services.ingestionPipelines.status import (
@@ -95,12 +93,7 @@ class TestCaseRunner(Processor):
             record.table, openmetadata_test_cases
         )
 
-        test_suite_runner = test_suite_source_factory.create(
-            record.service_type.lower(),
-            self.config,
-            self.metadata,
-            record.table,
-        ).get_data_quality_runner()
+        test_suite_runner = self.get_test_suite_runner(record.table)
 
         logger.debug(
             f"Found {len(openmetadata_test_cases)} test cases for table {record.table.fullyQualifiedName.root}"
@@ -357,3 +350,10 @@ class TestCaseRunner(Processor):
             else:
                 result.append(tc)
         return result
+
+    def get_test_suite_runner(self, table: Table):
+        return BaseTestSuiteRunner(
+            self.config,
+            self.metadata,
+            table,
+        ).get_data_quality_runner()

metadata/data_quality/runner/base_test_suite_source.py

@@ -15,25 +15,27 @@ Base source for the data quality used to instantiate a data quality runner with
 from copy import deepcopy
 from typing import Optional, cast
 
-from sqlalchemy import MetaData
-
+from metadata.data_quality.builders.validator_builder import ValidatorBuilder
 from metadata.data_quality.interface.test_suite_interface import TestSuiteInterface
-from metadata.data_quality.interface.test_suite_interface_factory import (
-    test_suite_interface_factory,
-)
 from metadata.data_quality.runner.core import DataTestsRunner
 from metadata.generated.schema.entity.data.table import Table
-from metadata.generated.schema.entity.services.connections.database.datalakeConnection import (
-    DatalakeConnection,
-)
 from metadata.generated.schema.entity.services.databaseService import DatabaseConnection
+from metadata.generated.schema.entity.services.serviceType import ServiceType
+from metadata.generated.schema.metadataIngestion.testSuitePipeline import (
+    TestSuitePipeline,
+)
 from metadata.generated.schema.metadataIngestion.workflow import (
     OpenMetadataWorkflowConfig,
 )
 from metadata.generated.schema.type.entityReference import EntityReference
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
-
-NON_SQA_DATABASE_CONNECTIONS = (DatalakeConnection,)
+from metadata.sampler.models import SampleConfig
+from metadata.sampler.sampler_interface import SamplerInterface
+from metadata.utils.profiler_utils import get_context_entities
+from metadata.utils.service_spec.service_spec import (
+    import_sampler_class,
+    import_test_suite_class,
+)
 
 
 class BaseTestSuiteRunner:
@@ -45,11 +47,16 @@ class BaseTestSuiteRunner:
         ometa_client: OpenMetadata,
         entity: Table,
     ):
+        self.validator_builder_class = ValidatorBuilder
         self._interface = None
         self.entity = entity
         self.service_conn_config = self._copy_service_config(config, self.entity.database)  # type: ignore
+        self._interface_type: str = self.service_conn_config.type.value.lower()
+
+        self.source_config = TestSuitePipeline.model_validate(
+            config.source.sourceConfig.config
+        )
         self.ometa_client = ometa_client
-        self.sqa_metadata = self._set_sqa_metadata()
 
     @property
     def interface(self) -> Optional[TestSuiteInterface]:
@@ -87,28 +94,47 @@ class BaseTestSuiteRunner:
 
         return config_copy
 
-    def _set_sqa_metadata(self):
-        """Set sqlalchemy metadata"""
-        if not isinstance(self.service_conn_config, NON_SQA_DATABASE_CONNECTIONS):
-            return MetaData()
-        return None
-
     def create_data_quality_interface(self) -> TestSuiteInterface:
         """Create data quality interface
 
         Returns:
             TestSuiteInterface: a data quality interface
         """
-        data_quality_interface: TestSuiteInterface = (
-            test_suite_interface_factory.create(
-                self.service_conn_config,
-                self.ometa_client,
-                self.entity,
-                sqa_metadata=self.sqa_metadata,
-            )
+        schema_entity, database_entity, _ = get_context_entities(
+            entity=self.entity, metadata=self.ometa_client
+        )
+        test_suite_class = import_test_suite_class(
+            ServiceType.Database,
+            source_type=self._interface_type,
+            source_config_type=self.service_conn_config.type.value,
+        )
+        sampler_class = import_sampler_class(
+            ServiceType.Database,
+            source_type=self._interface_type,
+            source_config_type=self.service_conn_config.type.value,
+        )
+        # This is shared between the sampler and DQ interfaces
+        sampler_interface: SamplerInterface = sampler_class.create(
+            service_connection_config=self.service_conn_config,
+            ometa_client=self.ometa_client,
+            entity=self.entity,
+            schema_entity=schema_entity,
+            database_entity=database_entity,
+            default_sample_config=SampleConfig(
+                profile_sample=self.source_config.profileSample,
+                profile_sample_type=self.source_config.profileSampleType,
+                sampling_method_type=self.source_config.samplingMethodType,
+            ),
+        )
+
+        self.interface: TestSuiteInterface = test_suite_class.create(
+            service_connection_config=self.service_conn_config,
+            ometa_client=self.ometa_client,
+            sampler=sampler_interface,
+            table_entity=self.entity,
+            validator_builder=self.validator_builder_class,
         )
-        self.interface = data_quality_interface
-        return data_quality_interface
+        return self.interface
 
     def get_data_quality_runner(self) -> DataTestsRunner:
         """Get a data quality runner

metadata/data_quality/source/test_suite.py

@@ -38,8 +38,8 @@ from metadata.ingestion.api.steps import Source
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.utils import fqn
 from metadata.utils.constants import CUSTOM_CONNECTOR_PREFIX
-from metadata.utils.importer import import_source_class
 from metadata.utils.logger import test_suite_logger
+from metadata.utils.service_spec.service_spec import import_source_class
 
 logger = test_suite_logger()
 

metadata/data_quality/validations/base_test_handler.py

@@ -17,19 +17,18 @@ from __future__ import annotations
 
 import reprlib
 from abc import ABC, abstractmethod
-from datetime import datetime
 from typing import TYPE_CHECKING, Callable, List, Optional, Type, TypeVar, Union
 
+from pydantic import BaseModel
+
 from metadata.data_quality.validations import utils
-from metadata.data_quality.validations.runtime_param_setter.param_setter import (
-    RuntimeParameterSetter,
-)
 from metadata.generated.schema.tests.basic import (
     TestCaseResult,
     TestCaseStatus,
     TestResultValue,
 )
 from metadata.generated.schema.tests.testCase import TestCase, TestCaseParameterValue
+from metadata.generated.schema.type.basic import Timestamp
 from metadata.profiler.processor.runner import QueryRunner
 
 if TYPE_CHECKING:
@@ -37,6 +36,7 @@ if TYPE_CHECKING:
 
 T = TypeVar("T", bound=Callable)
 R = TypeVar("R")
+S = TypeVar("S", bound=BaseModel)
 
 
 class BaseTestValidator(ABC):
@@ -45,13 +45,11 @@ class BaseTestValidator(ABC):
     This can be useful to resolve complex test parameters based on the parameters gibven by the user.
     """
 
-    runtime_parameter_setter: Optional[Type[RuntimeParameterSetter]] = None
-
     def __init__(
         self,
         runner: Union[QueryRunner, List["DataFrame"]],
         test_case: TestCase,
-        execution_date: Union[datetime, float],
+        execution_date: Timestamp,
     ) -> None:
         self.runner = runner
         self.test_case = test_case
@@ -80,7 +78,7 @@ class BaseTestValidator(ABC):
 
     def get_test_case_result_object(  # pylint: disable=too-many-arguments
         self,
-        execution_date: Union[datetime, float],
+        execution_date: Timestamp,
         status: TestCaseStatus,
         result: str,
         test_result_value: List[TestResultValue],
@@ -120,10 +118,10 @@ class BaseTestValidator(ABC):
             failed_rows = (
                 failed_rows if failed_rows is not None else (row_count - passed_rows)
             )
-            test_case_result.passedRows = passed_rows
-            test_case_result.failedRows = failed_rows
-            test_case_result.passedRowsPercentage = (passed_rows / row_count) * 100
-            test_case_result.failedRowsPercentage = (failed_rows / row_count) * 100  # type: ignore
+            test_case_result.passedRows = int(passed_rows)
+            test_case_result.failedRows = int(failed_rows)
+            test_case_result.passedRowsPercentage = float(passed_rows / row_count) * 100
+            test_case_result.failedRowsPercentage = float(failed_rows / row_count) * 100  # type: ignore
 
         return test_case_result
 
@@ -168,3 +166,10 @@ class BaseTestValidator(ABC):
     def get_predicted_value(self) -> Optional[str]:
         """Get predicted value"""
         return None
+
+    def get_runtime_parameters(self, setter_class: Type[S]) -> S:
+        """Get runtime parameters"""
+        for param in self.test_case.parameterValues or []:
+            if param.name == setter_class.__name__:
+                return setter_class.model_validate_json(param.value)
+        raise ValueError(f"Runtime parameter {setter_class.__name__} not found")

metadata/data_quality/validations/column/base/columnValuesToBeInSet.py

@@ -45,6 +45,7 @@ class BaseColumnValuesToBeInSetValidator(BaseTestValidator):
         Returns:
             TestCaseResult:
         """
+        matched = False
         allowed_values = self.get_test_case_param_value(
             self.test_case.parameterValues,  # type: ignore
             "allowedValues",
@@ -58,11 +59,12 @@ class BaseColumnValuesToBeInSetValidator(BaseTestValidator):
         try:
             column: Union[SQALikeColumn, Column] = self._get_column_name()
             res = self._run_results(Metrics.COUNT_IN_SET, column, values=allowed_values)
+            matched = res > 0
             if match_enum:
                 count = self._run_results(
                     Metrics.ROW_COUNT, column, values=allowed_values
                 )
-                res = count - res
+                matched = count - res == 0
         except (ValueError, RuntimeError) as exc:
             msg = f"Error computing {self.test_case.fullyQualifiedName}: {exc}"  # type: ignore
             logger.debug(traceback.format_exc())
@@ -81,7 +83,7 @@ class BaseColumnValuesToBeInSetValidator(BaseTestValidator):
 
         return self.get_test_case_result_object(
             self.execution_date,
-            self.get_test_case_status(res == 0 if match_enum else res >= 1),
+            self.get_test_case_status(matched),
             f"Found countInSet={res}.",
             [TestResultValue(name=ALLOWED_VALUE_COUNT, value=str(res))],
             row_count=row_count,

metadata/data_quality/validations/column/sqlalchemy/columnValueLengthsToBeBetween.py

@@ -40,7 +40,7 @@ class ColumnValueLengthsToBeBetweenValidator(
         """
         return self.get_column_name(
             self.test_case.entityLink.root,
-            inspect(self.runner.table).c,
+            inspect(self.runner.dataset).c,
         )
 
     def _run_results(self, metric: Metrics, column: Column) -> Optional[int]:

metadata/data_quality/validations/column/sqlalchemy/columnValueMaxToBeBetween.py

@@ -38,7 +38,7 @@ class ColumnValueMaxToBeBetweenValidator(
         """
         return self.get_column_name(
             self.test_case.entityLink.root,
-            inspect(self.runner.table).c,
+            inspect(self.runner.dataset).c,
         )
 
     def _run_results(self, metric: Metrics, column: Column) -> Optional[int]:

metadata/data_quality/validations/column/sqlalchemy/columnValueMeanToBeBetween.py

@@ -39,7 +39,7 @@ class ColumnValueMeanToBeBetweenValidator(
         """
         return self.get_column_name(
             self.test_case.entityLink.root,
-            inspect(self.runner.table).c,
+            inspect(self.runner.dataset).c,
         )
 
     def _run_results(self, metric: Metrics, column: Column) -> Optional[int]:

metadata/data_quality/validations/column/sqlalchemy/columnValueMedianToBeBetween.py

@@ -39,7 +39,7 @@ class ColumnValueMedianToBeBetweenValidator(
         """
         return self.get_column_name(
             self.test_case.entityLink.root,
-            inspect(self.runner.table).c,
+            inspect(self.runner.dataset).c,
         )
 
     def _run_results(self, metric: Metrics, column: Column) -> Optional[int]: