google-pso-data-validator 8.2.0__tar.gz → 8.3.0__tar.gz

{google_pso_data_validator-8.2.0/google_pso_data_validator.egg-info → google_pso_data_validator-8.3.0}/PKG-INFO

@@ -1,21 +1,21 @@
 Metadata-Version: 2.4
 Name: google-pso-data-validator
-Version: 8.2.0
+Version: 8.3.0
 Summary: A package to enable easy data validation
 Author: PSO DVT Engineering team
 Author-email: data-validator-eng@google.com
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: Flask>=2.2
-Requires-Dist: fsspec!=2025.3.1
+Requires-Dist: fsspec
 Requires-Dist: google-api-python-client>=2.144.0
 Requires-Dist: google-cloud-bigquery>=3.25.0
 Requires-Dist: google-cloud-bigquery-storage>=2.26.0
@@ -25,7 +25,7 @@ Requires-Dist: google-cloud-storage>=2.18.2
 Requires-Dist: ibis-framework==5.1.0
 Requires-Dist: impyla>=0.19.0
 Requires-Dist: jellyfish>=1.1.0
-Requires-Dist: pandas==2.0.3
+Requires-Dist: pandas
 Requires-Dist: parsy>=2.1
 Requires-Dist: psycopg2-binary>=2.9.9
 Requires-Dist: pyarrow==14.0.1
@@ -340,7 +340,7 @@ data-validation
                         Directory Path to store YAML Config Files
                         GCS: Provide a full gs:// path of the target directory. Eg: `gs://<BUCKET>/partitions_dir`
                         Local: Provide a relative path of the target directory. Eg: `partitions_dir`
-                        If invoked with -tbls parameter, the validations are stored in a directory named <schema>.<table>, otherwise the directory is named `custom.<random_string>`
+                        For custom queries, the yaml files are stored in CONFIG_DIR and, for tables the yamls are stored in a directory named <source_schema>.<table> within CONFIG_DIR.
   --partition-num INT, -pn INT
                         Number of partitions into which the table should be split, e.g. 1000 or 10000
                         In case this value exceeds the row count of the source/target table, it will be decreased to max(source_row_count, target_row_count)
@@ -653,9 +653,8 @@ The `--config-dir` flag will specify the directory with the YAML files to be exe
 
 ### Validation Reports
 
-The result handlers tell DVT where to store the results of each validation. The
-tool can write the results of a validation run to Google BigQuery, PostgreSQL
-or print to stdout (default). View the schema of the results table [here](https://github.com/GoogleCloudPlatform/professional-services-data-validator/blob/develop/terraform/results_schema.json).
+The result handlers tell DVT where to store the results of each validation. The tool can write the results of a validation run to Google BigQuery, PostgreSQL or print to stdout (default). See [result handler setup](https://github.com/GoogleCloudPlatform/professional-services-data-validator/blob/develop/docs/installation.md#result-handler-setup) for pre-requisites. View the schema of the BigQuery results table [here](https://github.com/GoogleCloudPlatform/professional-services-data-validator/blob/develop/terraform/results_schema.json).
+
 
 To output to BigQuery or PostgreSQL, simply include the `-rh` flag during a validation run including
 the schema and table name for the results.

{google_pso_data_validator-8.2.0 → google_pso_data_validator-8.3.0}/README.md

@@ -281,7 +281,7 @@ data-validation
                         Directory Path to store YAML Config Files
                         GCS: Provide a full gs:// path of the target directory. Eg: `gs://<BUCKET>/partitions_dir`
                         Local: Provide a relative path of the target directory. Eg: `partitions_dir`
-                        If invoked with -tbls parameter, the validations are stored in a directory named <schema>.<table>, otherwise the directory is named `custom.<random_string>`
+                        For custom queries, the yaml files are stored in CONFIG_DIR and, for tables the yamls are stored in a directory named <source_schema>.<table> within CONFIG_DIR.
   --partition-num INT, -pn INT
                         Number of partitions into which the table should be split, e.g. 1000 or 10000
                         In case this value exceeds the row count of the source/target table, it will be decreased to max(source_row_count, target_row_count)
@@ -594,9 +594,8 @@ The `--config-dir` flag will specify the directory with the YAML files to be exe
 
 ### Validation Reports
 
-The result handlers tell DVT where to store the results of each validation. The
-tool can write the results of a validation run to Google BigQuery, PostgreSQL
-or print to stdout (default). View the schema of the results table [here](https://github.com/GoogleCloudPlatform/professional-services-data-validator/blob/develop/terraform/results_schema.json).
+The result handlers tell DVT where to store the results of each validation. The tool can write the results of a validation run to Google BigQuery, PostgreSQL or print to stdout (default). See [result handler setup](https://github.com/GoogleCloudPlatform/professional-services-data-validator/blob/develop/docs/installation.md#result-handler-setup) for pre-requisites. View the schema of the BigQuery results table [here](https://github.com/GoogleCloudPlatform/professional-services-data-validator/blob/develop/terraform/results_schema.json).
+
 
 To output to BigQuery or PostgreSQL, simply include the `-rh` flag during a validation run including
 the schema and table name for the results.

{google_pso_data_validator-8.2.0 → google_pso_data_validator-8.3.0}/data_validation/__main__.py

@@ -524,8 +524,8 @@ def run_validation(config_manager: ConfigManager, dry_run=False, verbose=False):
         validation_builder=None,
         result_handler=None,
         verbose=verbose,
-        source_client=source_client,
-        target_client=target_client,
+        cached_source_client=source_client,
+        cached_target_client=target_client,
     ) as validator:
 
         if dry_run:
@@ -533,10 +533,12 @@ def run_validation(config_manager: ConfigManager, dry_run=False, verbose=False):
                 json.dumps(
                     {
                         "source_query": util.ibis_table_to_sql(
-                            validator.validation_builder.get_source_query()
+                            validator.validation_builder.get_source_query(),
+                            source_client,
                         ),
                         "target_query": util.ibis_table_to_sql(
-                            validator.validation_builder.get_target_query()
+                            validator.validation_builder.get_target_query(),
+                            target_client,
                         ),
                     },
                     indent=4,

{google_pso_data_validator-8.2.0 → google_pso_data_validator-8.3.0}/data_validation/cli_tools.py

@@ -1308,21 +1308,16 @@ def _get_result_handler(rc_value: str, sa_file=None) -> dict:
     if config[0] in connections:
         # We received connection_name.results_table.
         conn_from_file = get_connection(config[0])
-        if conn_from_file[consts.SOURCE_TYPE] == consts.SOURCE_TYPE_BIGQUERY:
+        if conn_from_file[consts.SOURCE_TYPE] in [
+            consts.SOURCE_TYPE_BIGQUERY,
+            consts.SOURCE_TYPE_POSTGRES,
+        ]:
             result_handler = {
                 consts.RH_TYPE: conn_from_file[consts.SOURCE_TYPE],
-                consts.PROJECT_ID: conn_from_file["project_id"],
                 consts.TABLE_ID: config[1],
-                consts.API_ENDPOINT: conn_from_file.get("api_endpoint", None),
-                consts.STORAGE_API_ENDPOINT: conn_from_file.get(
-                    "storage_api_endpoint", None
-                ),
-            }
-        elif conn_from_file[consts.SOURCE_TYPE] == consts.SOURCE_TYPE_POSTGRES:
-            result_handler = {
-                consts.RH_TYPE: conn_from_file[consts.SOURCE_TYPE],
-                consts.TABLE_ID: config[1],
-                consts.RH_CONN: conn_from_file,
+                # Only store the connection name in the result handler to avoid accidentally
+                # storing credentials in config files.
+                consts.RH_CONN: config[0],
             }
         # TODO Add filesytem handler too.
         else:

{google_pso_data_validator-8.2.0 → google_pso_data_validator-8.3.0}/data_validation/config_manager.py

@@ -671,20 +671,38 @@ class ConfigManager(object):
 
         This is because SQL Server text does not support the len() function to get the length in characters.
         Instead we must fall back to using ByteLength."""
+        return self._is_sql_server_type(
+            source_column_name, target_column_name, ["text", "ntext"]
+        )
+
+    def _is_sql_server_image(
+        self, source_column_name: str, target_column_name: str
+    ) -> bool:
+        """Returns True when either source or target column is of SQL Server image data type.
+
+        This is because SQL Server image is deprecated and not supported by a number of SQL functions.
+        """
+        return self._is_sql_server_type(
+            source_column_name, target_column_name, ["image"]
+        )
+
+    def _is_sql_server_type(
+        self, source_column_name: str, target_column_name: str, type_list: List[str]
+    ) -> bool:
+        """Returns True when either source or target column is of a SQL Server type listed in type_list."""
 
         raw_source_types = self.get_source_raw_data_types()
         raw_target_types = self.get_target_raw_data_types()
-        text_types = ("text", "ntext")
         return bool(
             (
                 self.source_client.name == "mssql"
                 and raw_source_types
-                and raw_source_types.get(source_column_name, [None])[0] in text_types
+                and raw_source_types.get(source_column_name, [None])[0] in type_list
             )
             or (
                 self.target_client.name == "mssql"
                 and raw_target_types
-                and raw_target_types.get(target_column_name, [None])[0] in text_types
+                and raw_target_types.get(target_column_name, [None])[0] in type_list
             )
         )
 
@@ -1075,6 +1093,11 @@ class ConfigManager(object):
                         f"Skipping {agg_type} on {column} due to data type: {column_type}"
                     )
                 continue
+            elif self._is_sql_server_image(column, column):
+                logging.info(
+                    f"Skipping {agg_type} on {column} due to SQL Server image data type"
+                )
+                continue
 
             if require_pre_agg_calc_field(
                 column_type, target_column_type, agg_type, cast_to_bigint
@@ -1252,8 +1275,25 @@ class ConfigManager(object):
             raise ValueError(
                 "Exclude columns flag cannot be present with column list '*'"
             )
+
         return casefold_columns
 
+    def _filter_columns_by_data_type(
+        self, source_columns: dict, target_columns: dict
+    ) -> tuple:
+        """Filter out columns with a data type that is incompatible with DVT."""
+        result_source_columns = source_columns.copy()
+        result_target_columns = target_columns.copy()
+        for source_column, target_column in zip(source_columns, target_columns):
+            if self._is_sql_server_image(source_column, target_column):
+                logging.info(
+                    f"Skipping column {source_column} due to SQL Server image data type"
+                )
+                result_source_columns.pop(source_column)
+                result_target_columns.pop(target_column)
+
+        return result_source_columns, result_target_columns
+
     def build_dependent_aliases(self, calc_type: str, col_list=None) -> List[Dict]:
         """This is a utility function for determining the required depth of all fields"""
         source_table = self.get_source_ibis_calculated_table()
@@ -1269,6 +1309,13 @@ class ConfigManager(object):
             casefold_target_columns, col_list
         )
 
+        (
+            casefold_source_columns,
+            casefold_target_columns,
+        ) = self._filter_columns_by_data_type(
+            casefold_source_columns, casefold_target_columns
+        )
+
         column_aliases = {}
         col_names = []
         for i, calc in enumerate(self._get_order_of_operations(calc_type)):
@@ -1325,6 +1372,9 @@ class ConfigManager(object):
         casefold_source_columns = self._filter_columns_by_column_list(
             casefold_source_columns, col_list, exclude_cols=exclude_cols
         )
+        casefold_source_columns, _ = self._filter_columns_by_data_type(
+            casefold_source_columns, casefold_source_columns
+        )
         return casefold_source_columns
 
     def auto_list_primary_keys(self) -> list:

{google_pso_data_validator-8.2.0 → google_pso_data_validator-8.3.0}/data_validation/data_validation.py

@@ -16,9 +16,11 @@ import json
 import logging
 import warnings
 from concurrent.futures import ThreadPoolExecutor
-import ibis.backends.pandas
-import pandas
 import uuid
+from typing import TYPE_CHECKING
+
+import ibis
+import pandas
 
 from data_validation import combiner, consts, metadata, util
 from data_validation.config_manager import ConfigManager
@@ -26,6 +28,9 @@ from data_validation.query_builder.random_row_builder import RandomRowBuilder
 from data_validation.schema_validation import SchemaValidation
 from data_validation.validation_builder import ValidationBuilder
 
+if TYPE_CHECKING:
+    from ibis.backends.base import BaseBackend
+
 """ The DataValidation class is where the code becomes source/target aware
 
     The class builds specific source and target clients and is likely where someone would go to
@@ -43,8 +48,8 @@ class DataValidation(object):
         schema_validator=None,
         result_handler=None,
         verbose=False,
-        source_client: ibis.backends.base.BaseBackend = None,
-        target_client: ibis.backends.base.BaseBackend = None,
+        cached_source_client: "BaseBackend" = None,
+        cached_target_client: "BaseBackend" = None,
     ):
         """Initialize a DataValidation client
 
@@ -54,19 +59,21 @@ class DataValidation(object):
             schema_validator (SchemaValidation): Optional instance of a SchemaValidation.
             result_handler (ResultHandler): Optional instance of as ResultHandler client.
             verbose (bool): If verbose, the Data Validation client will print the queries run.
-            source_client: Optional client to avoid unnecessary connections,
-            target_client: Optional client to avoid unnecessary connections,
+            cached_source_client: Optional client to avoid unnecessary connections,
+            cached_target_client: Optional client to avoid unnecessary connections,
         """
         self.verbose = verbose
-        self._fresh_connections = not bool(source_client and target_client)
+        self._fresh_connections = not bool(
+            cached_source_client and cached_target_client
+        )
 
         # Data Client Management
         self.config = config
 
         self.config_manager = ConfigManager(
             config,
-            source_client=source_client,
-            target_client=target_client,
+            source_client=cached_source_client,
+            target_client=cached_target_client,
             verbose=self.verbose,
         )
 

{google_pso_data_validator-8.2.0 → google_pso_data_validator-8.3.0}/data_validation/find_tables.py

@@ -60,15 +60,9 @@ def _compare_match_tables(source_table_map, target_table_map, score_cutoff=0.8)
     return table_configs
 
 
-def _get_table_map(
-    client: "ibis.backends.base.BaseBackend", allowed_schemas=None, include_views=False
-):
-    """Return dict with searchable keys for table matching."""
+def _get_table_map_from_obj_list(table_objs: list) -> dict:
+    """Convert list of schema, table tuples into dict with searchable keys for table matching."""
     table_map = {}
-    table_objs = clients.get_all_tables(
-        client, allowed_schemas=allowed_schemas, tables_only=(not include_views)
-    )
-
     for table_obj in table_objs:
         table_key = ".".join([t for t in table_obj if t])
         table_map[table_key] = {
@@ -76,9 +70,25 @@ def _get_table_map(
             consts.CONFIG_TABLE_NAME: table_obj[1],
         }
 
+    # Post process table_map and lower case table_keys, if possible.
+    for table_key in [_ for _ in table_map if _ != _.casefold()]:
+        if table_key.casefold() not in table_map:
+            # Only lower case the key if there isn't one already.
+            table_map[table_key.casefold()] = table_map.pop(table_key)
+
     return table_map
 
 
+def _get_table_map(
+    client: "ibis.backends.base.BaseBackend", allowed_schemas=None, include_views=False
+) -> dict:
+    """Return dict with searchable keys for table matching."""
+    table_objs = clients.get_all_tables(
+        client, allowed_schemas=allowed_schemas, tables_only=(not include_views)
+    )
+    return _get_table_map_from_obj_list(table_objs)
+
+
 def get_mapped_table_configs(
     source_client: "ibis.backends.base.BaseBackend",
     target_client: "ibis.backends.base.BaseBackend",

{google_pso_data_validator-8.2.0 → google_pso_data_validator-8.3.0}/data_validation/partition_builder.py

@@ -18,8 +18,6 @@ import pandas
 import logging
 import re
 import datetime
-import hashlib
-import base64
 from typing import List, Dict, TYPE_CHECKING
 
 from data_validation import cli_tools, consts, util
@@ -30,7 +28,8 @@ from data_validation.validation_builder import list_to_sublists
 
 if TYPE_CHECKING:
     from argparse import Namespace
-    import ibis.expr.types.Table
+    from ibis.backends.base import BaseBackend
+    from ibis.expr.types.relations import Table as IbisTable
 
 
 class PartitionBuilder:
@@ -40,6 +39,12 @@ class PartitionBuilder:
         self.args = args
         self.config_dir = self._get_arg_config_dir()
 
+    @staticmethod
+    def _definitely_no_time_part(value: datetime.datetime) -> bool:
+        """Oracle date has a time portion - this function ensures we don't truncate the time when we really want it."""
+        # The function name is a bit of a misnomer, it's checking if there is a time part.
+        return value.hour + value.minute + value.second + value.microsecond == 0
+
     def _get_arg_config_dir(self) -> str:
         """Return String yaml config folder path."""
         if not self.args.config_dir:
@@ -101,7 +106,7 @@ class PartitionBuilder:
         self._store_partitions(yaml_configs_list)
 
     @staticmethod
-    def _extract_where(table_expr: "ibis.expr.types.Table") -> str:
+    def _extract_where(table_expr: "IbisTable", client: "BaseBackend") -> str:
         """Given a ibis table expression with a filter (i.e. WHERE) clause, this function extracts the
            where clause in plain text.
 
@@ -111,8 +116,9 @@ class PartitionBuilder:
         # This extraction of the where clause is a bit of a hack. To extract it correctly, the SQL table
         # expression should be correctly parsed and the where clause extracted. Perhaps use something like Sqlglot.
         sql_where_expr = re.split(
-            r"\sWHERE\s", util.ibis_table_to_sql(table_expr), flags=re.I
+            r"\sWHERE\s", util.ibis_table_to_sql(table_expr, client), flags=re.I
         )[-1]
+
         sql_string_re = re.compile(r"'(?:''|\\'|[^'])*'")
         sql_not_string_re = re.compile(r"[^']+")
         sql_where_less_ws = ""
@@ -253,7 +259,6 @@ class PartitionBuilder:
             # Up until this point, we have built the table expression, have not executed the query yet.
             # The query is now executed to find the first element of each partition
             first_elements = first_keys_table.execute().to_numpy()
-
             # The objective is to generate the SQL expression string that is saved in the yaml file as a
             # filters property. This SQL expression is used as a filter during validation to ensure
             # that the yaml file is only validating the specific partition. This string is backend specific as
@@ -280,13 +285,14 @@ class PartitionBuilder:
                     values[0].date()
                     if key_column.type().is_date()
                     and isinstance(values[0], datetime.datetime)
+                    and self._definitely_no_time_part(values[0])
                     else values[0]
                 )
                 if len(keys) == 1:
-                    return key_column < value
+                    return key_column < ibis.literal(value)
                 else:
-                    return (key_column < value) | (
-                        (key_column == value)
+                    return (key_column < ibis.literal(value)) | (
+                        (key_column == ibis.literal(value))
                         & less_than_value(table, keys[1:], values[1:])
                     )
 
@@ -297,14 +303,16 @@ class PartitionBuilder:
                     values[0].date()
                     if key_column.type().is_date()
                     and isinstance(values[0], datetime.datetime)
+                    and self._definitely_no_time_part(values[0])
                     else values[0]
                 )
 
                 if len(keys) == 1:
-                    return key_column >= value
+                    return key_column >= ibis.literal(value)
                 else:
-                    return (key_column > value) | (
-                        (key_column == value) & geq_value(table, keys[1:], values[1:])
+                    return (key_column > ibis.literal(value)) | (
+                        (key_column == ibis.literal(value))
+                        & geq_value(table, keys[1:], values[1:])
                     )
 
             filter_source_clause = less_than_value(
@@ -320,11 +328,13 @@ class PartitionBuilder:
             source_where_list.append(
                 self._extract_where(
                     source_table.filter(filter_source_clause),
+                    config_manager.source_client,
                 )
             )
             target_where_list.append(
                 self._extract_where(
                     target_table.filter(filter_target_clause),
+                    config_manager.target_client,
                 )
             )
 
@@ -350,11 +360,13 @@ class PartitionBuilder:
                 source_where_list.append(
                     self._extract_where(
                         source_table.filter(filter_source_clause),
+                        config_manager.source_client,
                     )
                 )
                 target_where_list.append(
                     self._extract_where(
                         target_table.filter(filter_target_clause),
+                        config_manager.target_client,
                     )
                 )
             filter_source_clause = geq_value(
@@ -370,11 +382,13 @@ class PartitionBuilder:
             source_where_list.append(
                 self._extract_where(
                     source_table.filter(filter_source_clause),
+                    config_manager.source_client,
                 )
             )
             target_where_list.append(
                 self._extract_where(
                     target_table.filter(filter_target_clause),
+                    config_manager.target_client,
                 )
             )
             master_filter_list.append([source_where_list, target_where_list])
@@ -409,14 +423,7 @@ class PartitionBuilder:
             if config_manager.source_table:
                 dir_name = config_manager.full_source_table
             else:
-                dir_name = (
-                    "custom."
-                    + base64.b64encode(
-                        hashlib.sha256(
-                            config_manager.source_query.encode("utf-8")
-                        ).digest()
-                    ).decode("ascii")[:5]
-                )
+                dir_name = ""
             filter_list = partition_filters[ind]
 
             if src_config_dict.get(dir_name) is None:

{google_pso_data_validator-8.2.0 → google_pso_data_validator-8.3.0}/data_validation/result_handlers/base_backend.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import logging
-from typing import TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING
 
 import ibis
 
@@ -58,7 +58,7 @@ class BaseBackendResultHandler:
     """Write results of data validation to a backend."""
 
     _table_id: str = None
-    _status_list: list = None
+    _status_list: Optional[list] = None
     _text_format: str = None
 
     def _filter_by_status_list(self, result_df: "DataFrame") -> "DataFrame":

{google_pso_data_validator-8.2.0 → google_pso_data_validator-8.3.0}/data_validation/result_handlers/bigquery.py

@@ -15,6 +15,10 @@
 """Output validation report to BigQuery tables"""
 
 import logging
+from typing import Optional
+
+import google.oauth2.service_account
+
 
 from data_validation import clients, consts, exceptions, util
 from data_validation.result_handlers.base_backend import BaseBackendResultHandler
@@ -24,6 +28,14 @@ BQRH_WRITE_MESSAGE = "Results written to BigQuery"
 BQRH_NO_WRITE_MESSAGE = "No results to write to BigQuery"
 
 
+def credentials_from_key_path(sa_key_path):
+    if not sa_key_path:
+        return None
+    return google.oauth2.service_account.Credentials.from_service_account_file(
+        sa_key_path
+    )
+
+
 class BigQueryResultHandler(BaseBackendResultHandler):
     """Write results of data validation to BigQuery.
 
@@ -38,7 +50,7 @@ class BigQueryResultHandler(BaseBackendResultHandler):
     def __init__(
         self,
         bigquery_client,
-        status_list: list = None,
+        status_list: Optional[list] = None,
         table_id: str = "pso_data_validator.results",
         text_format: str = consts.FORMAT_TYPE_TABLE,
     ):
@@ -50,10 +62,10 @@ class BigQueryResultHandler(BaseBackendResultHandler):
     @staticmethod
     def get_handler_for_project(
         project_id,
-        status_list=None,
+        status_list: Optional[list] = None,
         table_id: str = "pso_data_validator.results",
-        credentials=None,
-        api_endpoint: str = None,
+        sa_key_path: Optional[str] = None,
+        api_endpoint: Optional[str] = None,
         text_format: str = consts.FORMAT_TYPE_TABLE,
     ):
         """Return BigQueryResultHandler instance for given project.
@@ -70,6 +82,39 @@ class BigQueryResultHandler(BaseBackendResultHandler):
                 This allows the user to influence the text results written via logger.debug.
                 See: https://github.com/GoogleCloudPlatform/professional-services-data-validator/issues/871
         """
+
+        credentials = credentials_from_key_path(sa_key_path)
+        client = clients.get_google_bigquery_client(
+            project_id, credentials=credentials, api_endpoint=api_endpoint
+        )
+        return BigQueryResultHandler(
+            client,
+            status_list=status_list,
+            table_id=table_id,
+            text_format=text_format,
+        )
+
+    @staticmethod
+    def get_handler_for_connection(
+        connection_config: dict,
+        status_list: Optional[list] = None,
+        table_id: str = "pso_data_validator.results",
+        text_format: str = consts.FORMAT_TYPE_TABLE,
+    ):
+        """Return BigQueryResultHandler instance for given connection config.
+
+        Args:
+            table_id (str): Table ID used for validation results.
+            status_list (list): provided status to filter the results with
+            text_format (str, optional):
+                This allows the user to influence the text results written via logger.debug.
+                See: https://github.com/GoogleCloudPlatform/professional-services-data-validator/issues/871
+        """
+        project_id = connection_config[consts.PROJECT_ID]
+        credentials = credentials_from_key_path(
+            connection_config.get(consts.GOOGLE_SERVICE_ACCOUNT_KEY_PATH)
+        )
+        api_endpoint = connection_config.get(consts.API_ENDPOINT)
         client = clients.get_google_bigquery_client(
             project_id, credentials=credentials, api_endpoint=api_endpoint
         )