openmetadata-ingestion 1.8.1.0__py3-none-any.whl → 1.8.2.0__py3-none-any.whl

metadata/ingestion/source/database/snowflake/metadata.py

@@ -16,8 +16,9 @@ import traceback
 from datetime import datetime
 from typing import Iterable, List, Optional, Tuple
 
+import sqlalchemy.types as sqltypes
 import sqlparse
-from snowflake.sqlalchemy.custom_types import VARIANT
+from snowflake.sqlalchemy.custom_types import VARIANT, StructuredType
 from snowflake.sqlalchemy.snowdialect import SnowflakeDialect, ischema_names
 from sqlalchemy.engine.reflection import Inspector
 from sqlparse.sql import Function, Identifier, Token
@@ -124,15 +125,36 @@ from metadata.utils.sqlalchemy_utils import (
 )
 from metadata.utils.tag_utils import get_ometa_tag_and_classification
 
+
+class MAP(StructuredType):
+    __visit_name__ = "MAP"
+
+    # Default to VARCHAR for key and value types if not provided
+    # This is a workaround to avoid the error:
+    # sqlalchemy.exc.ArgumentError: Map type requires a key_type and value_type
+    # when creating a table with a MAP column.
+    def __init__(
+        self,
+        key_type: sqltypes.TypeEngine = sqltypes.VARCHAR,
+        value_type: sqltypes.TypeEngine = sqltypes.VARCHAR,
+        not_null: bool = False,
+    ):
+        self.key_type = key_type
+        self.value_type = value_type
+        self.not_null = not_null
+        super().__init__()
+
+
 ischema_names["VARIANT"] = VARIANT
 ischema_names["GEOGRAPHY"] = create_sqlalchemy_type("GEOGRAPHY")
 ischema_names["GEOMETRY"] = create_sqlalchemy_type("GEOMETRY")
 ischema_names["VECTOR"] = create_sqlalchemy_type("VECTOR")
+ischema_names["MAP"] = MAP
 
 logger = ingestion_logger()
 
-
-SnowflakeDialect._json_deserializer = json.loads  # pylint: disable=protected-access
+# pylint: disable=protected-access
+SnowflakeDialect._json_deserializer = json.loads
 SnowflakeDialect.get_table_names = get_table_names
 SnowflakeDialect.get_view_names = get_view_names
 SnowflakeDialect.get_stream_names = get_stream_names
@@ -142,15 +164,11 @@ SnowflakeDialect.get_table_comment = get_table_comment
 SnowflakeDialect.get_all_view_definitions = get_all_view_definitions
 SnowflakeDialect.get_view_definition = get_view_definition
 SnowflakeDialect.get_unique_constraints = get_unique_constraints
-SnowflakeDialect._get_schema_columns = (  # pylint: disable=protected-access
-    get_schema_columns
-)
+SnowflakeDialect._get_schema_columns = get_schema_columns
 Inspector.get_table_names = get_table_names_reflection
 Inspector.get_view_names = get_view_names_reflection
 Inspector.get_stream_names = get_stream_names_reflection
-SnowflakeDialect._current_database_schema = (  # pylint: disable=protected-access
-    _current_database_schema
-)
+SnowflakeDialect._current_database_schema = _current_database_schema
 SnowflakeDialect.get_pk_constraint = get_pk_constraint
 SnowflakeDialect.get_foreign_keys = get_foreign_keys
 SnowflakeDialect.get_columns = get_columns
@@ -160,6 +178,7 @@ Inspector.get_stream_definition = get_stream_definition
 SnowflakeDialect._get_schema_foreign_keys = get_schema_foreign_keys
 
 
+# pylint: disable=too-many-public-methods
 class SnowflakeSource(
     ExternalTableLineageMixin,
     CommonDbSourceService,
@@ -926,4 +945,3 @@ class SnowflakeSource(
         logger.debug(
             f"Processing ownership is not supported for {self.service_connection.type.name}"
         )
-        return None

metadata/ingestion/source/database/snowflake/service_spec.py

@@ -6,10 +6,10 @@ from metadata.ingestion.source.database.snowflake.data_diff.data_diff import (
 )
 from metadata.ingestion.source.database.snowflake.lineage import SnowflakeLineageSource
 from metadata.ingestion.source.database.snowflake.metadata import SnowflakeSource
-from metadata.ingestion.source.database.snowflake.profiler.profiler import (
-    SnowflakeProfiler,
-)
 from metadata.ingestion.source.database.snowflake.usage import SnowflakeUsageSource
+from metadata.profiler.interface.sqlalchemy.snowflake.profiler_interface import (
+    SnowflakeProfilerInterface,
+)
 from metadata.sampler.sqlalchemy.snowflake.sampler import SnowflakeSampler
 from metadata.utils.service_spec.default import DefaultDatabaseSpec
 
@@ -17,7 +17,7 @@ ServiceSpec = DefaultDatabaseSpec(
     metadata_source_class=SnowflakeSource,
     lineage_source_class=SnowflakeLineageSource,
     usage_source_class=SnowflakeUsageSource,
-    profiler_class=SnowflakeProfiler,
+    profiler_class=SnowflakeProfilerInterface,
     test_suite_class=SnowflakeTestSuiteInterface,
     sampler_class=SnowflakeSampler,
     data_diff=SnowflakeTableParameter,

metadata/ingestion/source/database/stored_procedures_mixin.py

@@ -41,6 +41,7 @@ from metadata.ingestion.lineage.sql_lineage import get_lineage_by_query
 from metadata.ingestion.models.ometa_lineage import OMetaLineageRequest
 from metadata.ingestion.models.topology import Queue
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
+from metadata.utils.filters import filter_by_stored_procedure
 from metadata.utils.logger import ingestion_logger
 from metadata.utils.stored_procedures import get_procedure_name_from_call
 from metadata.utils.time_utils import datetime_to_timestamp
@@ -289,6 +290,15 @@ class StoredProcedureLineageMixin(ABC):
             or []
         ):
             if procedure:
+                if filter_by_stored_procedure(
+                    self.source_config.storedProcedureFilterPattern,
+                    procedure.name.root,
+                ):
+                    self.status.filter(
+                        procedure.name.root,
+                        "Stored Procedure Filtered Out",
+                    )
+                    continue
                 logger.debug(f"Processing Lineage for [{procedure.name}]")
                 for query_by_procedure in (
                     queries_dict.get(procedure.name.root.lower()) or []

metadata/ingestion/source/database/unitycatalog/metadata.py

@@ -559,17 +559,18 @@ class UnitycatalogSource(
             ).connect() as connection:
                 for query, tag_fqn_builder in query_tag_fqn_builder_mapping:
                     for tag in connection.execute(query):
-                        yield from get_ometa_tag_and_classification(
-                            tag_fqn=FullyQualifiedEntityName(
-                                fqn._build(*tag_fqn_builder(tag))
-                            ),  # pylint: disable=protected-access
-                            tags=[tag.tag_value],
-                            classification_name=tag.tag_name,
-                            tag_description=UNITY_CATALOG_TAG,
-                            classification_description=UNITY_CATALOG_TAG_CLASSIFICATION,
-                            metadata=self.metadata,
-                            system_tags=True,
-                        )
+                        if tag.tag_value:
+                            yield from get_ometa_tag_and_classification(
+                                tag_fqn=FullyQualifiedEntityName(
+                                    fqn._build(*tag_fqn_builder(tag))
+                                ),  # pylint: disable=protected-access
+                                tags=[tag.tag_value],
+                                classification_name=tag.tag_name,
+                                tag_description=UNITY_CATALOG_TAG,
+                                classification_description=UNITY_CATALOG_TAG_CLASSIFICATION,
+                                metadata=self.metadata,
+                                system_tags=True,
+                            )
         except Exception as exc:
             logger.debug(traceback.format_exc())
             logger.warning(
@@ -612,17 +613,18 @@ class UnitycatalogSource(
             ).connect() as connection:
                 for query, tag_fqn_builder in query_tag_fqn_builder_mapping:
                     for tag in connection.execute(query):
-                        yield from get_ometa_tag_and_classification(
-                            tag_fqn=FullyQualifiedEntityName(
-                                fqn._build(*tag_fqn_builder(tag))
-                            ),  # pylint: disable=protected-access
-                            tags=[tag.tag_value],
-                            classification_name=tag.tag_name,
-                            tag_description=UNITY_CATALOG_TAG,
-                            classification_description=UNITY_CATALOG_TAG_CLASSIFICATION,
-                            metadata=self.metadata,
-                            system_tags=True,
-                        )
+                        if tag.tag_value:
+                            yield from get_ometa_tag_and_classification(
+                                tag_fqn=FullyQualifiedEntityName(
+                                    fqn._build(*tag_fqn_builder(tag))
+                                ),  # pylint: disable=protected-access
+                                tags=[tag.tag_value],
+                                classification_name=tag.tag_name,
+                                tag_description=UNITY_CATALOG_TAG,
+                                classification_description=UNITY_CATALOG_TAG_CLASSIFICATION,
+                                metadata=self.metadata,
+                                system_tags=True,
+                            )
         except Exception as exc:
             logger.debug(traceback.format_exc())
             logger.warning(f"Error getting tags for schema {schema_name}: {exc}")

metadata/ingestion/source/metadata/amundsen/metadata.py

@@ -147,18 +147,18 @@ class AmundsenSource(Source):
     def _iter(self, *_, **__) -> Iterable[Either[Entity]]:
         table_entities = self.client.execute_query(NEO4J_AMUNDSEN_TABLE_QUERY)
         for table in table_entities:
-            yield from Either(right=self.create_table_entity(table))
+            yield from self.create_table_entity(table)
 
         user_entities = self.client.execute_query(NEO4J_AMUNDSEN_USER_QUERY)
         for user in user_entities:
-            yield from Either(right=self.create_user_entity(user))
-            yield from Either(right=self.add_owner_to_entity(user))
+            yield from self.create_user_entity(user)
+            yield from self.add_owner_to_entity(user)
 
         dashboard_entities = self.client.execute_query(NEO4J_AMUNDSEN_DASHBOARD_QUERY)
         for dashboard in dashboard_entities:
-            yield from Either(right=self.create_dashboard_service(dashboard))
-            yield from Either(right=self.create_chart_entity(dashboard))
-            yield from Either(right=self.create_dashboard_entity(dashboard))
+            yield from self.create_dashboard_service(dashboard)
+            yield from self.create_chart_entity(dashboard)
+            yield from self.create_dashboard_entity(dashboard)
 
     def create_user_entity(self, user) -> Iterable[Either[OMetaUserProfile]]:
         try:

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

@@ -13,16 +13,45 @@
 Interfaces with database for all database engine
 supporting sqlalchemy abstraction layer
 """
+from typing import List, Type, cast
+
 from sqlalchemy import Column, inspect
 
+from metadata.generated.schema.entity.data.table import SystemProfile
 from metadata.profiler.interface.sqlalchemy.profiler_interface import (
     SQAProfilerInterface,
 )
+from metadata.profiler.metrics.system.bigquery.system import (
+    BigQuerySystemMetricsComputer,
+)
+from metadata.profiler.metrics.system.system import System
+from metadata.profiler.processor.runner import QueryRunner
+from metadata.utils.logger import profiler_interface_registry_logger
+
+logger = profiler_interface_registry_logger()
 
 
 class BigQueryProfilerInterface(SQAProfilerInterface):
     """BigQuery profiler interface"""
 
+    def _compute_system_metrics(
+        self,
+        metrics: Type[System],
+        runner: QueryRunner,
+        *args,
+        **kwargs,
+    ) -> List[SystemProfile]:
+        logger.debug(f"Computing {metrics.name()} metric for {runner.table_name}")
+        self.system_metrics_class = cast(
+            Type[BigQuerySystemMetricsComputer], self.system_metrics_class
+        )
+        instance = self.system_metrics_class(
+            session=self.session,
+            runner=runner,
+            usage_location=self.service_connection_config.usageLocation,
+        )
+        return instance.get_system_metrics()
+
     def _get_struct_columns(self, columns: dict, parent: str):
         """"""
         # pylint: disable=import-outside-toplevel

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

@@ -13,25 +13,55 @@
 Interfaces with database for all database engine
 supporting sqlalchemy abstraction layer
 """
-from typing import List
+from typing import List, Type, cast
 
 from pyhive.sqlalchemy_hive import HiveCompiler
 from sqlalchemy import Column
 
 from metadata.generated.schema.entity.data.table import Column as OMColumn
-from metadata.generated.schema.entity.data.table import ColumnName, DataType
+from metadata.generated.schema.entity.data.table import (
+    ColumnName,
+    DataType,
+    SystemProfile,
+)
 from metadata.generated.schema.entity.services.databaseService import (
     DatabaseServiceType,
 )
 from metadata.profiler.interface.sqlalchemy.profiler_interface import (
     SQAProfilerInterface,
 )
+from metadata.profiler.metrics.system.databricks.system import (
+    DatabricksSystemMetricsComputer,
+)
+from metadata.profiler.metrics.system.system import System
 from metadata.profiler.orm.converter.base import build_orm_col
+from metadata.profiler.processor.runner import QueryRunner
+from metadata.utils.logger import profiler_interface_registry_logger
+
+logger = profiler_interface_registry_logger()
 
 
 class DatabricksProfilerInterface(SQAProfilerInterface):
     """Databricks profiler interface"""
 
+    def _compute_system_metrics(
+        self,
+        metrics: Type[System],
+        runner: QueryRunner,
+        *args,
+        **kwargs,
+    ) -> List[SystemProfile]:
+        logger.debug(f"Computing {metrics.name()} metric for {runner.table_name}")
+        self.system_metrics_class = cast(
+            Type[DatabricksSystemMetricsComputer], self.system_metrics_class
+        )
+        instance = self.system_metrics_class(
+            session=self.session,
+            runner=runner,
+            catalog=self.service_connection_config.catalog,
+        )
+        return instance.get_system_metrics()
+
     def visit_column(self, *args, **kwargs):
         result = super(  # pylint: disable=bad-super-call
             HiveCompiler, self

metadata/profiler/interface/sqlalchemy/profiler_interface.py

@@ -26,7 +26,7 @@ from typing import Any, Dict, List, Optional, Type, Union
 
 from sqlalchemy import Column, inspect, text
 from sqlalchemy.exc import DBAPIError, ProgrammingError, ResourceClosedError
-from sqlalchemy.orm import scoped_session
+from sqlalchemy.orm import Session, scoped_session
 
 from metadata.generated.schema.entity.data.table import (
     CustomMetricProfile,
@@ -51,7 +51,7 @@ 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.metrics.system.system import System, SystemMetricsComputer
+from metadata.profiler.metrics.system.system import System, SystemMetricsRegistry
 from metadata.profiler.orm.functions.table_metric_computer import TableMetricComputer
 from metadata.profiler.orm.registry import Dialects
 from metadata.profiler.processor.metric_filter import MetricFilter
@@ -111,13 +111,9 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
 
         self._table = self.sampler.raw_dataset
         self.create_session()
-        self.system_metrics_computer = self.initialize_system_metrics_computer()
-
-    def initialize_system_metrics_computer(self) -> SystemMetricsComputer:
-        """Initialize system metrics computer. Override this if you want to use a metric source with
-        state or other dependencies.
-        """
-        return SystemMetricsComputer()
+        self.system_metrics_class = SystemMetricsRegistry.get(
+            self.session.get_bind().dialect
+        )
 
     def create_session(self):
         self.session_factory = self._session_factory()
@@ -362,7 +358,8 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
         *args,
         **kwargs,
     ) -> List[SystemProfile]:
-        """Get system metric for tables
+        """Get system metric for tables. Override this in the interface if you want to use a metric source with
+        for other sources.
 
         Args:
             metric_type: type of metric
@@ -372,8 +369,10 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
         Returns:
             dictionnary of results
         """
-        logger.debug(f"Computing system metrics for {runner.table_name}")
-        return self.system_metrics_computer.get_system_metrics(runner=runner)
+        logger.debug(
+            f"No implementation found for {self.session.get_bind().dialect.name} for {metrics.name()} metric"
+        )
+        return []
 
     def _create_thread_safe_runner(self, session, column=None):
         """Create thread safe runner"""

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

@@ -0,0 +1,50 @@
+#  Copyright 2025 Collate
+#  Licensed under the Collate Community License, Version 1.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  https://github.com/open-metadata/OpenMetadata/blob/main/ingestion/LICENSE
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""
+Interfaces with database for all database engine
+supporting sqlalchemy abstraction layer
+"""
+from typing import List, Type, cast
+
+from metadata.generated.schema.entity.data.table import SystemProfile
+from metadata.profiler.interface.sqlalchemy.profiler_interface import (
+    SQAProfilerInterface,
+)
+from metadata.profiler.metrics.system.redshift.system import (
+    RedshiftSystemMetricsComputer,
+)
+from metadata.profiler.metrics.system.system import System
+from metadata.profiler.processor.runner import QueryRunner
+from metadata.utils.logger import profiler_interface_registry_logger
+
+logger = profiler_interface_registry_logger()
+
+
+class RedshiftProfilerInterface(SQAProfilerInterface):
+    """Redshift profiler interface"""
+
+    def _compute_system_metrics(
+        self,
+        metrics: Type[System],
+        runner: QueryRunner,
+        *args,
+        **kwargs,
+    ) -> List[SystemProfile]:
+        logger.debug(f"Computing {metrics.name()} metric for {runner.table_name}")
+        self.system_metrics_class = cast(
+            Type[RedshiftSystemMetricsComputer], self.system_metrics_class
+        )
+        instance = self.system_metrics_class(
+            session=self.session,
+            runner=runner,
+        )
+        return instance.get_system_metrics()

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

@@ -14,10 +14,18 @@ Interfaces with database for all database engine
 supporting sqlalchemy abstraction layer
 """
 
+from typing import List, Type, cast
+
+from metadata.generated.schema.entity.data.table import SystemProfile
 from metadata.profiler.interface.sqlalchemy.profiler_interface import (
     OVERFLOW_ERROR_CODES,
     SQAProfilerInterface,
 )
+from metadata.profiler.metrics.system.snowflake.system import (
+    SnowflakeSystemMetricsComputer,
+)
+from metadata.profiler.metrics.system.system import System
+from metadata.profiler.processor.runner import QueryRunner
 from metadata.utils.logger import profiler_interface_registry_logger
 
 logger = profiler_interface_registry_logger()
@@ -36,6 +44,18 @@ class SnowflakeProfilerInterface(SQAProfilerInterface):
         super().create_session()
         self.set_session_tag(self.session)
 
+    def _compute_system_metrics(
+        self, metrics: Type[System], runner: QueryRunner, *args, **kwargs
+    ) -> List[SystemProfile]:
+        self.system_metrics_class = cast(
+            Type[SnowflakeSystemMetricsComputer], self.system_metrics_class
+        )
+        instance = self.system_metrics_class(
+            session=self.session,
+            runner=runner,
+        )
+        return instance.get_system_metrics()
+
     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/{ingestion/source/database/bigquery/profiler → profiler/metrics/system/bigquery}/system.py

@@ -3,16 +3,17 @@
 from typing import List
 
 from pydantic import TypeAdapter
+from sqlalchemy.orm import Session
 
 from metadata.generated.schema.entity.data.table import DmlOperationType, SystemProfile
 from metadata.ingestion.source.database.bigquery.queries import BigQueryQueryResult
 from metadata.profiler.metrics.system.dml_operation import DatabaseDMLOperations
 from metadata.profiler.metrics.system.system import (
     CacheProvider,
-    EmptySystemMetricsSource,
-    SQASessionProvider,
     SystemMetricsComputer,
+    register_system_metrics,
 )
+from metadata.profiler.orm.registry import PythonDialects
 from metadata.profiler.processor.runner import QueryRunner
 from metadata.utils.logger import profiler_logger
 from metadata.utils.time_utils import datetime_to_timestamp
@@ -20,36 +21,32 @@ from metadata.utils.time_utils import datetime_to_timestamp
 logger = profiler_logger()
 
 
-class BigQuerySystemMetricsSource(
-    SQASessionProvider, EmptySystemMetricsSource, CacheProvider
-):
+@register_system_metrics(PythonDialects.BigQuery)
+class BigQuerySystemMetricsComputer(SystemMetricsComputer, CacheProvider):
     """BigQuery system metrics source class"""
 
-    def get_kwargs(self, **kwargs):
-        runner: QueryRunner = kwargs.get("runner")
-        return {
-            "table": runner.table_name,
-            "project_id": runner.session.get_bind().url.host,
-            "dataset_id": runner.schema_name,
-            "usage_location": kwargs.get("usage_location"),
-        }
+    def __init__(
+        self,
+        session: Session,
+        runner: QueryRunner,
+        usage_location: str,
+    ):
+        self.session = session
+        self.table = runner.table_name
+        self.project_id = runner.session.get_bind().url.host
+        self.dataset_id = runner.schema_name
+        self.usage_location = usage_location
 
-    def get_deletes(self, **kwargs) -> List[SystemProfile]:
-        table, project_id, usage_location, dataset_id = (
-            kwargs.get("table"),
-            kwargs.get("project_id"),
-            kwargs.get("usage_location"),
-            kwargs.get("dataset_id"),
-        )
+    def get_deletes(self) -> List[SystemProfile]:
         return self.get_system_profile(
-            project_id,
-            dataset_id,
-            table,
+            self.project_id,
+            self.dataset_id,
+            self.table,
             list(
                 self.get_queries_by_operation(
-                    usage_location,
-                    project_id,
-                    dataset_id,
+                    self.usage_location,
+                    self.project_id,
+                    self.dataset_id,
                     [
                         DatabaseDMLOperations.DELETE,
                     ],
@@ -59,21 +56,15 @@ class BigQuerySystemMetricsSource(
             DmlOperationType.DELETE,
         )
 
-    def get_updates(self, **kwargs) -> List[SystemProfile]:
-        table, project_id, usage_location, dataset_id = (
-            kwargs.get("table"),
-            kwargs.get("project_id"),
-            kwargs.get("usage_location"),
-            kwargs.get("dataset_id"),
-        )
+    def get_updates(self) -> List[SystemProfile]:
         return self.get_system_profile(
-            project_id,
-            dataset_id,
-            table,
+            self.project_id,
+            self.dataset_id,
+            self.table,
             self.get_queries_by_operation(
-                usage_location,
-                project_id,
-                dataset_id,
+                self.usage_location,
+                self.project_id,
+                self.dataset_id,
                 [
                     DatabaseDMLOperations.UPDATE,
                     DatabaseDMLOperations.MERGE,
@@ -83,21 +74,15 @@ class BigQuerySystemMetricsSource(
             DmlOperationType.UPDATE,
         )
 
-    def get_inserts(self, **kwargs) -> List[SystemProfile]:
-        table, project_id, usage_location, dataset_id = (
-            kwargs.get("table"),
-            kwargs.get("project_id"),
-            kwargs.get("usage_location"),
-            kwargs.get("dataset_id"),
-        )
+    def get_inserts(self) -> List[SystemProfile]:
         return self.get_system_profile(
-            project_id,
-            dataset_id,
-            table,
+            self.project_id,
+            self.dataset_id,
+            self.table,
             self.get_queries_by_operation(
-                usage_location,
-                project_id,
-                dataset_id,
+                self.usage_location,
+                self.project_id,
+                self.dataset_id,
                 [
                     DatabaseDMLOperations.INSERT,
                     DatabaseDMLOperations.MERGE,
@@ -127,7 +112,7 @@ class BigQuerySystemMetricsSource(
         return self.get_or_update_cache(
             f"{project_id}.{dataset_id}",
             BigQueryQueryResult.get_for_table,
-            session=super().get_session(),
+            session=self.session,
             usage_location=usage_location,
             project_id=project_id,
             dataset_id=dataset_id,
@@ -154,13 +139,10 @@ class BigQuerySystemMetricsSource(
                     "rowsAffected": getattr(q, rows_affected_field),
                 }
                 for q in query_results
-                if getattr(q, rows_affected_field, -1) > 0
+                if getattr(q, rows_affected_field)
+                or -1 > 0
                 and q.project_id == project_id
                 and q.dataset_id == dataset_id
                 and q.table_name == table
             ]
         )
-
-
-class BigQuerySystemMetricsComputer(SystemMetricsComputer, BigQuerySystemMetricsSource):
-    pass