openmetadata-ingestion 1.5.13.0__py3-none-any.whl → 1.6.0.0rc2__py3-none-any.whl

{openmetadata_ingestion-1.5.13.0.dist-info → openmetadata_ingestion-1.6.0.0rc2.dist-info}/entry_points.txt

@@ -3,3 +3,6 @@ provider_info = airflow_provider_openmetadata:get_provider_config
 
 [console_scripts]
 metadata = metadata.cmd:metadata
+
+[pytest11]
+pytest_openmetadata = _openmetadata_testutils.pytest_openmetadata.plugin

metadata/data_quality/interface/test_suite_interface_factory.py

@@ -1,128 +0,0 @@
-#  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.
-"""
-Interface factory
-"""
-import traceback
-from logging import Logger
-
-from metadata.data_quality.interface.pandas.pandas_test_suite_interface import (
-    PandasTestSuiteInterface,
-)
-from metadata.data_quality.interface.sqlalchemy.databricks.test_suite_interface import (
-    DatabricksTestSuiteInterface,
-)
-from metadata.data_quality.interface.sqlalchemy.snowflake.test_suite_interface import (
-    SnowflakeTestSuiteInterface,
-)
-from metadata.data_quality.interface.sqlalchemy.sqa_test_suite_interface import (
-    SQATestSuiteInterface,
-)
-from metadata.data_quality.interface.sqlalchemy.unity_catalog.test_suite_interface import (
-    UnityCatalogTestSuiteInterface,
-)
-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.connections.database.databricksConnection import (
-    DatabricksConnection,
-)
-from metadata.generated.schema.entity.services.connections.database.datalakeConnection import (
-    DatalakeConnection,
-)
-from metadata.generated.schema.entity.services.connections.database.snowflakeConnection import (
-    SnowflakeConnection,
-)
-from metadata.generated.schema.entity.services.connections.database.unityCatalogConnection import (
-    UnityCatalogConnection,
-)
-from metadata.generated.schema.entity.services.databaseService import DatabaseConnection
-from metadata.ingestion.ometa.ometa_api import OpenMetadata
-from metadata.utils.logger import test_suite_logger
-
-logger: Logger = test_suite_logger()
-
-
-class TestSuiteInterfaceFactory:
-    """Factory class for the data quality interface"""
-
-    def __init__(self):
-        """Initialize the interface factory"""
-        self._interface_type = {
-            "base": SQATestSuiteInterface,
-            DatalakeConnection.__name__: PandasTestSuiteInterface,
-        }
-
-    def register(self, interface_type: str, interface: TestSuiteInterface):
-        """Register the interface
-
-        Args:
-            interface_type (str): type of the interface
-            interface (TestSuiteInterface): a class that implements the TestSuiteInterface
-        """
-        self._interface_type[interface_type] = interface
-
-    def register_many(self, interface_dict):
-        """
-        Registers multiple profiler interfaces at once.
-
-        Args:
-            interface_dict: A dictionary mapping connection class names (strings) to their
-            corresponding profiler interface classes.
-        """
-        for interface_type, interface_class in interface_dict.items():
-            self.register(interface_type, interface_class)
-
-    def create(
-        self,
-        service_connection_config: DatabaseConnection,
-        ometa_client: OpenMetadata,
-        table_entity: Table,
-        *args,
-        **kwargs,
-    ) -> TestSuiteInterface:
-        """Create the interface
-
-        Args:
-            service_connection_config (DatabaseService): a database service object
-
-        Raises:
-            AttributeError: if no connection is found in the database service object
-
-        Returns:
-            TestSuiteInterface:
-        """
-        try:
-            connection_type = service_connection_config.__class__.__name__
-        except AttributeError as err:
-            logger.debug(traceback.format_exc())
-            raise AttributeError(f"Could not instantiate interface class: {err}")
-        interface = self._interface_type.get(connection_type)
-
-        if not interface:
-            interface = self._interface_type["base"]
-
-        return interface(
-            service_connection_config, ometa_client, table_entity, *args, **kwargs
-        )
-
-
-test_suite_interface_factory = TestSuiteInterfaceFactory()
-
-
-test_suite_interface = {
-    DatabaseConnection.__name__: SQATestSuiteInterface,
-    DatalakeConnection.__name__: PandasTestSuiteInterface,
-    SnowflakeConnection.__name__: SnowflakeTestSuiteInterface,
-    UnityCatalogConnection.__name__: UnityCatalogTestSuiteInterface,
-    DatabricksConnection.__name__: DatabricksTestSuiteInterface,
-}
-
-test_suite_interface_factory.register_many(test_suite_interface)

metadata/data_quality/runner/test_suite_source_factory.py

@@ -1,38 +0,0 @@
-#  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.
-
-"""
-Factory class for creating test suite source objects
-"""
-
-from metadata.data_quality.runner.base_test_suite_source import BaseTestSuiteRunner
-
-
-class TestSuiteRunnerFactory:
-    """Creational factory for test suite source objects"""
-
-    def __init__(self):
-        self._source_type = {"base": BaseTestSuiteRunner}
-
-    def register_source(self, source_type: str, source_class):
-        """Register a new source type"""
-        self._source_type[source_type] = source_class
-
-    def create(self, source_type: str, *args, **kwargs) -> BaseTestSuiteRunner:
-        """Create source object based on source type"""
-        source_class = self._source_type.get(source_type)
-        if not source_class:
-            source_class = self._source_type["base"]
-            return source_class(*args, **kwargs)
-        return source_class(*args, **kwargs)
-
-
-test_suite_source_factory = TestSuiteRunnerFactory()

metadata/generated/schema/entity/services/connections/dashboard/mstrConnection.py

@@ -1,54 +0,0 @@
-# generated by datamodel-codegen:
-#   filename:  entity/services/connections/dashboard/mstrConnection.json
-#   timestamp: 2024-11-28T18:44:30+00:00
-
-from __future__ import annotations
-
-from enum import Enum
-from typing import Optional
-
-from pydantic import AnyUrl, ConfigDict, Field
-from typing_extensions import Annotated
-
-from metadata.ingestion.models.custom_pydantic import BaseModel, CustomSecretStr
-
-from .. import connectionBasicType
-
-
-class MstrType(Enum):
-    Mstr = 'Mstr'
-
-
-class MstrConnection(BaseModel):
-    model_config = ConfigDict(
-        extra='forbid',
-    )
-    type: Annotated[
-        Optional[MstrType],
-        Field(MstrType.Mstr, description='Service Type', title='Service Type'),
-    ]
-    username: Annotated[
-        str,
-        Field(
-            description='Username to connect to MSTR. This user should have privileges to read all the metadata in MSTR.',
-            title='Username',
-        ),
-    ]
-    password: Annotated[
-        Optional[CustomSecretStr],
-        Field(None, description='Password to connect to MSTR.', title='Password'),
-    ]
-    hostPort: Annotated[
-        AnyUrl,
-        Field(
-            description='Host and Port of the Metabase instance.', title='Host and Port'
-        ),
-    ]
-    projectName: Annotated[
-        Optional[str],
-        Field(None, description='MSTR Project Name', title='Project Name'),
-    ]
-    supportsMetadataExtraction: Annotated[
-        Optional[connectionBasicType.SupportsMetadataExtraction],
-        Field(None, title='Supports Metadata Extraction'),
-    ]

metadata/profiler/interface/profiler_interface_factory.py

@@ -1,107 +0,0 @@
-#  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.
-
-"""
-Factory class for creating profiler interface objects
-"""
-
-import importlib
-from typing import Dict, cast
-
-from metadata.generated.schema.entity.services.connections.database.bigQueryConnection import (
-    BigQueryConnection,
-)
-from metadata.generated.schema.entity.services.connections.database.databricksConnection import (
-    DatabricksConnection,
-)
-from metadata.generated.schema.entity.services.connections.database.datalakeConnection import (
-    DatalakeConnection,
-)
-from metadata.generated.schema.entity.services.connections.database.db2Connection import (
-    Db2Connection,
-)
-from metadata.generated.schema.entity.services.connections.database.dynamoDBConnection import (
-    DynamoDBConnection,
-)
-from metadata.generated.schema.entity.services.connections.database.mariaDBConnection import (
-    MariaDBConnection,
-)
-from metadata.generated.schema.entity.services.connections.database.mongoDBConnection import (
-    MongoDBConnection,
-)
-from metadata.generated.schema.entity.services.connections.database.singleStoreConnection import (
-    SingleStoreConnection,
-)
-from metadata.generated.schema.entity.services.connections.database.snowflakeConnection import (
-    SnowflakeConnection,
-)
-from metadata.generated.schema.entity.services.connections.database.trinoConnection import (
-    TrinoConnection,
-)
-from metadata.generated.schema.entity.services.connections.database.unityCatalogConnection import (
-    UnityCatalogConnection,
-)
-from metadata.generated.schema.entity.services.databaseService import DatabaseConnection
-from metadata.profiler.factory import Factory
-from metadata.profiler.interface.profiler_interface import ProfilerInterface
-
-
-class ProfilerInterfaceFactory(Factory):
-    def create(self, interface_type: str, *args, **kwargs):
-        """Create interface object based on interface type"""
-        interface_class_path = profiler_class_mapping.get(
-            interface_type, profiler_class_mapping[DatabaseConnection.__name__]
-        )
-        try:
-            module_path, class_name = interface_class_path.rsplit(".", 1)
-            module = importlib.import_module(module_path)
-            profiler_class = getattr(module, class_name)
-        except (ImportError, AttributeError) as e:
-            raise ImportError(f"Error importing {class_name} from {module_path}: {e}")
-        profiler_class = cast(ProfilerInterface, profiler_class)
-        return profiler_class.create(*args, **kwargs)
-
-
-profiler_interface_factory = ProfilerInterfaceFactory()
-
-BASE_PROFILER_PATH = "metadata.profiler.interface"
-SQLALCHEMY_PROFILER_PATH = f"{BASE_PROFILER_PATH}.sqlalchemy"
-NOSQL_PROFILER_PATH = (
-    f"{BASE_PROFILER_PATH}.nosql.profiler_interface.NoSQLProfilerInterface"
-)
-PANDAS_PROFILER_PATH = (
-    f"{BASE_PROFILER_PATH}.pandas.profiler_interface.PandasProfilerInterface"
-)
-
-# Configuration for dynamic imports
-profiler_class_mapping: Dict[str, str] = {
-    DatabaseConnection.__name__: SQLALCHEMY_PROFILER_PATH
-    + ".profiler_interface.SQAProfilerInterface",
-    BigQueryConnection.__name__: SQLALCHEMY_PROFILER_PATH
-    + ".bigquery.profiler_interface.BigQueryProfilerInterface",
-    SingleStoreConnection.__name__: SQLALCHEMY_PROFILER_PATH
-    + ".single_store.profiler_interface.SingleStoreProfilerInterface",
-    DatalakeConnection.__name__: PANDAS_PROFILER_PATH,
-    MariaDBConnection.__name__: SQLALCHEMY_PROFILER_PATH
-    + ".mariadb.profiler_interface.MariaDBProfilerInterface",
-    SnowflakeConnection.__name__: SQLALCHEMY_PROFILER_PATH
-    + ".snowflake.profiler_interface.SnowflakeProfilerInterface",
-    TrinoConnection.__name__: SQLALCHEMY_PROFILER_PATH
-    + ".trino.profiler_interface.TrinoProfilerInterface",
-    UnityCatalogConnection.__name__: SQLALCHEMY_PROFILER_PATH
-    + ".unity_catalog.profiler_interface.UnityCatalogProfilerInterface",
-    DatabricksConnection.__name__: SQLALCHEMY_PROFILER_PATH
-    + ".databricks.profiler_interface.DatabricksProfilerInterface",
-    Db2Connection.__name__: SQLALCHEMY_PROFILER_PATH
-    + ".db2.profiler_interface.DB2ProfilerInterface",
-    MongoDBConnection.__name__: NOSQL_PROFILER_PATH,
-    DynamoDBConnection.__name__: NOSQL_PROFILER_PATH,
-}

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

@@ -1,54 +0,0 @@
-#  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.
-
-"""
-Bigquery System Metric Queries
-"""
-from datetime import datetime
-
-from pydantic import BaseModel
-
-from metadata.profiler.metrics.system.dml_operation import DatabaseDMLOperations
-
-
-class BigQueryQueryResult(BaseModel):
-    table_name: dict
-    timestamp: datetime
-    query_type: str
-    dml_statistics: dict
-
-
-DML_STAT_TO_DML_STATEMENT_MAPPING = {
-    "inserted_row_count": DatabaseDMLOperations.INSERT.value,
-    "deleted_row_count": DatabaseDMLOperations.DELETE.value,
-    "updated_row_count": DatabaseDMLOperations.UPDATE.value,
-}
-
-JOBS = """
-    SELECT
-        statement_type,
-        start_time,
-        destination_table,
-        dml_statistics
-    FROM
-        `region-{usage_location}`.INFORMATION_SCHEMA.JOBS
-    WHERE
-        DATE(creation_time) >= CURRENT_DATE() - 1 AND
-        destination_table.dataset_id = '{dataset_id}' AND
-        destination_table.project_id = '{project_id}' AND
-        statement_type IN (
-            '{insert}',
-            '{update}',
-            '{delete}',
-            '{merge}'
-        )
-    ORDER BY creation_time DESC;
-"""

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

@@ -1,103 +0,0 @@
-#  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.
-
-"""
-Redshift System Metric Queries and queries operations
-"""
-
-from typing import List
-
-from sqlalchemy import text
-from sqlalchemy.orm import Session
-
-from metadata.utils.profiler_utils import QueryResult
-
-STL_QUERY = """
-    with data as (
-        select
-            {alias}.*
-        from 
-            pg_catalog.stl_insert si
-            {join_type} join pg_catalog.stl_delete sd on si.query = sd.query
-        where 
-            {condition}
-    )
-	SELECT
-        SUM(data."rows") AS "rows",
-        sti."database",
-        sti."schema",
-        sti."table",
-        DATE_TRUNC('second', data.starttime) AS starttime
-    FROM
-        data
-        INNER JOIN  pg_catalog.svv_table_info sti ON data.tbl = sti.table_id
-    where
-        sti."database" = '{database}' AND
-       	sti."schema" = '{schema}' AND
-        "rows" != 0 AND
-        DATE(data.starttime) >= CURRENT_DATE - 1
-    GROUP BY 2,3,4,5
-    ORDER BY 5 DESC
-"""
-
-
-def get_query_results(
-    session: Session,
-    query,
-    operation,
-) -> List[QueryResult]:
-    """get query results either from cache or from the database
-
-    Args:
-        cache (Optional[List[QueryResult]]): cache results
-        session (Session): session
-        query (_type_): query
-        operation (_type_): operation
-
-    Returns:
-        List[QueryResult]:
-    """
-    cursor = session.execute(text(query))
-    results = [
-        QueryResult(
-            database_name=row.database,
-            schema_name=row.schema,
-            table_name=row.table,
-            query_text=None,
-            query_type=operation,
-            timestamp=row.starttime,
-            rows=row.rows,
-        )
-        for row in cursor
-    ]
-
-    return results
-
-
-def get_metric_result(ddls: List[QueryResult], table_name: str) -> List:
-    """Given query results, retur the metric result
-
-    Args:
-        ddls (List[QueryResult]): list of query results
-        table_name (str): table name
-
-    Returns:
-        List:
-    """
-    return [
-        {
-            "timestamp": int(ddl.timestamp.timestamp() * 1000),
-            "operation": ddl.query_type,
-            "rowsAffected": ddl.rows,
-        }
-        for ddl in ddls
-        if ddl.table_name == table_name
-    ]

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

@@ -1,191 +0,0 @@
-#  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.
-
-"""
-Snowflake System Metric Queries and query operations
-"""
-
-import re
-import traceback
-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,
-    get_identifiers_from_string,
-)
-
-logger = profiler_logger()
-
-INFORMATION_SCHEMA_QUERY = """
-    SELECT
-        QUERY_ID,
-        QUERY_TEXT,
-        QUERY_TYPE,
-        START_TIME,
-        ROWS_INSERTED,
-        ROWS_UPDATED,
-        ROWS_DELETED
-    FROM "SNOWFLAKE"."ACCOUNT_USAGE"."QUERY_HISTORY"
-    WHERE
-    start_time>= DATEADD('DAY', -1, CURRENT_TIMESTAMP)
-    AND QUERY_TEXT ILIKE '%{tablename}%'
-    AND QUERY_TYPE IN (
-        '{insert}',
-        '{update}',
-        '{delete}',
-        '{merge}'
-    )
-    AND EXECUTION_STATUS = 'SUCCESS';
-"""
-
-RESULT_SCAN = """
-    SELECT *
-    FROM TABLE(RESULT_SCAN('{query_id}'));
-    """
-
-
-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,
-    ometa_client: OpenMetadata,
-    db_service: DatabaseService,
-) -> Optional[SnowflakeQueryResult]:
-    """
-    Run a regex lookup on the query to identify which operation ran against the table.
-
-    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
-    """
-
-    try:
-        dict_row = dict(row)
-        query_text = dict_row.get("QUERY_TEXT", dict_row.get("query_text"))
-        logger.debug(f"Trying to parse query:\n{query_text}\n")
-
-        identifier = _parse_query(query_text)
-        if not identifier:
-            return None
-
-        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]):
-            return None
-
-        if (
-            database.lower() == database_name.lower()
-            and schema.lower() == schema_name.lower()
-        ):
-            return SnowflakeQueryResult(
-                query_id=dict_row.get("QUERY_ID", dict_row.get("query_id")),
-                database_name=database_name.lower(),
-                schema_name=schema_name.lower(),
-                table_name=table_name.lower(),
-                query_text=query_text,
-                query_type=dict_row.get("QUERY_TYPE", dict_row.get("query_type")),
-                timestamp=dict_row.get("START_TIME", dict_row.get("start_time")),
-                rows_inserted=dict_row.get(
-                    "ROWS_INSERTED", dict_row.get("rows_inserted")
-                ),
-                rows_updated=dict_row.get("ROWS_UPDATED", dict_row.get("rows_updated")),
-                rows_deleted=dict_row.get("ROWS_DELETED", dict_row.get("rows_deleted")),
-            )
-    except Exception:
-        logger.debug(traceback.format_exc())
-        return None
-
-    return None