openmetadata-ingestion 1.9.7.1__py3-none-any.whl → 1.9.8.0__py3-none-any.whl

metadata/ingestion/ometa/mixins/profile_mixin.py

@@ -0,0 +1,77 @@
+#  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.
+"""
+Mixin class containing Pipeline specific methods
+
+To be used by OpenMetadata class
+"""
+
+from typing import Optional, Type, TypeVar
+
+from pydantic import BaseModel
+
+from metadata.generated.schema.type.entityProfile import EntityProfile, ProfileTypeEnum
+from metadata.ingestion.ometa.client import REST
+from metadata.ingestion.ometa.models import EntityList
+from metadata.ingestion.ometa.utils import get_entity_type
+from metadata.utils.logger import ometa_logger
+
+logger = ometa_logger()
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class OMetaProfileMixin:
+    """
+    OpenMetadata API methods related to Profiles.
+
+    To be inherited by OpenMetadata
+    """
+
+    client: REST
+
+    def get_profile_data_by_type(
+        self,
+        entity_type: Type[T],
+        start_ts: int,
+        end_ts: int,
+        profile_type: Optional[ProfileTypeEnum] = None,
+    ) -> EntityList[EntityProfile]:
+        """List all profile data for a given entity type. To get all the profile for
+        a specific profile type use the profile_type parameter.
+
+        Args:
+            entity_type (Type[T]): Entity type
+            start_ts (int): Start timestamp
+            end_ts (int): End timestamp
+            profile_type (Optional[ProfileTypeEnum]): Profile type
+
+        Returns:
+            EntityList[EntityProfile]: EntityList list object
+        """
+        entity_type = get_entity_type(entity_type)
+        params = {
+            "startTs": start_ts,
+            "endTs": end_ts,
+        }
+        if profile_type:
+            params["profileType"] = profile_type.value
+        resp = self.client.get(
+            f"{self.get_suffix(EntityProfile)}/{entity_type}",
+            data=params,
+        )
+        paging = resp["paging"]
+        return EntityList[EntityProfile](
+            entities=[EntityProfile(**entity) for entity in resp["data"]],
+            total=paging["total"],
+            after=paging["after"],
+            before=paging["before"],
+        )

metadata/ingestion/ometa/ometa_api.py

@@ -47,6 +47,7 @@ from metadata.ingestion.ometa.mixins.ingestion_pipeline_mixin import (
 from metadata.ingestion.ometa.mixins.mlmodel_mixin import OMetaMlModelMixin
 from metadata.ingestion.ometa.mixins.patch_mixin import OMetaPatchMixin
 from metadata.ingestion.ometa.mixins.pipeline_mixin import OMetaPipelineMixin
+from metadata.ingestion.ometa.mixins.profile_mixin import OMetaProfileMixin
 from metadata.ingestion.ometa.mixins.query_mixin import OMetaQueryMixin
 from metadata.ingestion.ometa.mixins.role_policy_mixin import OMetaRolePolicyMixin
 from metadata.ingestion.ometa.mixins.search_index_mixin import OMetaSearchIndexMixin
@@ -129,6 +130,7 @@ class OpenMetadata(
     OMetaCustomPropertyMixin,
     OMetaSuggestionsMixin,
     OMetaDomainMixin,
+    OMetaProfileMixin,
     Generic[T, C],
 ):
     """

metadata/ingestion/ometa/routes.py

@@ -193,6 +193,7 @@ 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.generated.schema.tests.testSuite import TestSuite
+from metadata.generated.schema.type.entityProfile import EntityProfile
 
 ROUTES = {
     MlModel.__name__: "/mlmodels",
@@ -327,4 +328,5 @@ ROUTES = {
     # Data Contracts
     DataContract.__name__: "/dataContracts",
     CreateDataContractRequest.__name__: "/dataContracts",
+    EntityProfile.__name__: "/entity/profiles",
 }

metadata/ingestion/source/dashboard/metabase/client.py

@@ -160,9 +160,9 @@ class MetabaseClient:
                     chart = MetabaseChart.model_validate(chart_data)
                     charts_dict[chart.id] = chart
             return charts_dict
-        except Exception:
+        except Exception as e:
             logger.debug(traceback.format_exc())
-            logger.warning("Failed to fetch the cards")
+            logger.warning(f"Failed to fetch the cards : {e}")
         return {}
 
     def _create_default_dashboard_details(

metadata/ingestion/source/dashboard/metabase/models.py

@@ -11,9 +11,11 @@
 """
 Metabase Models
 """
+import ast
+import json
 from typing import List, Optional
 
-from pydantic import BaseModel, BeforeValidator, Field
+from pydantic import BaseModel, BeforeValidator, Field, field_validator
 from typing_extensions import Annotated
 
 MetabaseStrId = Annotated[str, BeforeValidator(lambda x: str(x))]
@@ -84,6 +86,52 @@ class MetabaseChart(BaseModel):
     display: Optional[str] = None
     dashboard_ids: List[str] = []
 
+    @field_validator("dataset_query", mode="before")
+    @classmethod
+    def parse_dataset_query(cls, v):
+        if v is None:
+            return None
+
+        # If it's already a dict or DatasetQuery object, return as is
+        if isinstance(v, (dict, DatasetQuery)):
+            return v
+
+        # If it's a string, try multiple parsing strategies
+        if isinstance(v, str):
+            # Strategy 1: Try standard JSON parsing
+            try:
+                return json.loads(v)
+            except json.JSONDecodeError:
+                pass
+
+            # Strategy 2: Try ast.literal_eval for Python dict strings
+            try:
+                parsed = ast.literal_eval(v)
+                if isinstance(parsed, dict):
+                    return parsed
+            except (ValueError, SyntaxError):
+                pass
+
+            # Strategy 3: More sophisticated quote replacement
+            try:
+                # Handle None values and booleans
+                json_str = (
+                    v.replace("'", '"')
+                    .replace("None", "null")
+                    .replace("True", "true")
+                    .replace("False", "false")
+                )
+                return json.loads(json_str)
+            except json.JSONDecodeError:
+                pass
+
+            # If all strategies fail, log and return None
+            print(f"Failed to parse dataset_query string: {v[:100]}...")
+            return None
+
+        # For any other type, return as is and let Pydantic handle validation
+        return v
+
 
 class DashCard(BaseModel):
     card: MetabaseChart

metadata/ingestion/source/database/athena/utils.py

@@ -173,7 +173,7 @@ def get_columns(self, connection, table_name, schema=None, **kw):
             for glue_col in glue_columns:
                 col_name = glue_col["Name"]
                 col_type = glue_col["Type"]
-                col_comment = glue_col.get("Comment", "")
+                col_comment = glue_col.get("Comment")
                 col_parameters = glue_col.get("Parameters", {})
 
                 # Check if this is a non-current Iceberg column

metadata/ingestion/source/database/bigquery/connection.py

@@ -31,6 +31,7 @@ from metadata.generated.schema.entity.services.connections.testConnectionResult
     TestConnectionResult,
 )
 from metadata.generated.schema.security.credentials.gcpCredentials import (
+    GcpADC,
     GcpCredentialsPath,
 )
 from metadata.generated.schema.security.credentials.gcpValues import (
@@ -68,25 +69,21 @@ def get_connection_url(connection: BigQueryConnection) -> str:
             connection.credentials.gcpConfig.projectId, SingleProjectId
         ):
             if not connection.credentials.gcpConfig.projectId.root:
-                return f"{connection.scheme.value}://{connection.billingProjectId or connection.credentials.gcpConfig.projectId.root or ''}"
+                return f"{connection.scheme.value}://{connection.credentials.gcpConfig.projectId.root or ''}"
             if (
                 not connection.credentials.gcpConfig.privateKey
                 and connection.credentials.gcpConfig.projectId.root
             ):
                 project_id = connection.credentials.gcpConfig.projectId.root
-                os.environ["GOOGLE_CLOUD_PROJECT"] = (
-                    connection.billingProjectId or project_id
-                )
-            return f"{connection.scheme.value}://{connection.billingProjectId or connection.credentials.gcpConfig.projectId.root}"
+                os.environ["GOOGLE_CLOUD_PROJECT"] = project_id
+            return f"{connection.scheme.value}://{connection.credentials.gcpConfig.projectId.root}"
         elif isinstance(connection.credentials.gcpConfig.projectId, MultipleProjectId):
             for project_id in connection.credentials.gcpConfig.projectId.root:
                 if not connection.credentials.gcpConfig.privateKey and project_id:
                     # Setting environment variable based on project id given by user / set in ADC
-                    os.environ["GOOGLE_CLOUD_PROJECT"] = (
-                        connection.billingProjectId or project_id
-                    )
-                return f"{connection.scheme.value}://{connection.billingProjectId or project_id}"
-            return f"{connection.scheme.value}://{connection.billingProjectId or ''}"
+                    os.environ["GOOGLE_CLOUD_PROJECT"] = project_id
+                return f"{connection.scheme.value}://{project_id}"
+            return f"{connection.scheme.value}://"
 
     # If gcpConfig is the JSON key path and projectId is defined, we use it by default
     elif (
@@ -96,13 +93,27 @@ def get_connection_url(connection: BigQueryConnection) -> str:
         if isinstance(  # pylint: disable=no-else-return
             connection.credentials.gcpConfig.projectId, SingleProjectId
         ):
-            return f"{connection.scheme.value}://{connection.billingProjectId or connection.credentials.gcpConfig.projectId.root}"
+            return f"{connection.scheme.value}://{connection.credentials.gcpConfig.projectId.root}"
+
+        elif isinstance(connection.credentials.gcpConfig.projectId, MultipleProjectId):
+            for project_id in connection.credentials.gcpConfig.projectId.root:
+                return f"{connection.scheme.value}://{project_id}"
+
+    # If gcpConfig is the GCP ADC and projectId is defined, we use it by default
+    elif (
+        isinstance(connection.credentials.gcpConfig, GcpADC)
+        and connection.credentials.gcpConfig.projectId
+    ):
+        if isinstance(  # pylint: disable=no-else-return
+            connection.credentials.gcpConfig.projectId, SingleProjectId
+        ):
+            return f"{connection.scheme.value}://{connection.credentials.gcpConfig.projectId.root}"
 
         elif isinstance(connection.credentials.gcpConfig.projectId, MultipleProjectId):
             for project_id in connection.credentials.gcpConfig.projectId.root:
-                return f"{connection.scheme.value}://{connection.billingProjectId or project_id}"
+                return f"{connection.scheme.value}://{project_id}"
 
-    return f"{connection.scheme.value}://{connection.billingProjectId or ''}"
+    return f"{connection.scheme.value}://"
 
 
 def get_connection(connection: BigQueryConnection) -> Engine:
@@ -110,10 +121,15 @@ def get_connection(connection: BigQueryConnection) -> Engine:
     Prepare the engine and the GCP credentials
     """
     set_google_credentials(gcp_credentials=connection.credentials)
+    kwargs = {}
+    if connection.billingProjectId:
+        kwargs["billing_project_id"] = connection.billingProjectId
+
     return create_generic_db_connection(
         connection=connection,
         get_connection_url_fn=get_connection_url,
         get_connection_args_fn=get_connection_args_common,
+        **kwargs,
     )
 
 

metadata/ingestion/source/database/bigquery/queries.py

@@ -211,13 +211,18 @@ class BigQueryQueryResult(BaseModel):
         usage_location: str,
         dataset_id: str,
         project_id: str,
+        billing_project_id: Optional[str] = None,
     ):
+        # Use billing project for the INFORMATION_SCHEMA query if provided
+        query_project_id = billing_project_id or project_id
+
         rows = session.execute(
             text(
                 JOBS.format(
                     usage_location=usage_location,
                     dataset_id=dataset_id,
                     project_id=project_id,
+                    query_project_id=query_project_id,
                     insert=DatabaseDMLOperations.INSERT.value,
                     update=DatabaseDMLOperations.UPDATE.value,
                     delete=DatabaseDMLOperations.DELETE.value,
@@ -240,7 +245,7 @@ JOBS = """
         dml_statistics.deleted_row_count as deleted_row_count,
         dml_statistics.updated_row_count as updated_row_count
     FROM
-        `region-{usage_location}`.INFORMATION_SCHEMA.JOBS
+        `{query_project_id}`.`region-{usage_location}`.INFORMATION_SCHEMA.JOBS
     WHERE
         DATE(creation_time) >= CURRENT_DATE() - 1 AND
         destination_table.dataset_id = '{dataset_id}' AND

metadata/ingestion/source/database/dbt/metadata.py

@@ -511,6 +511,7 @@ class DbtSource(DbtServiceSource):
             self.context.get().exposures = {}
             self.context.get().dbt_tests = {}
             self.context.get().run_results_generate_time = None
+
             # Since we'll be processing multiple run_results for a single project
             # we'll only consider the first run_results generated_at time
             if (
@@ -520,6 +521,9 @@ class DbtSource(DbtServiceSource):
                 self.context.get().run_results_generate_time = (
                     dbt_objects.dbt_run_results[0].metadata.generated_at
                 )
+            dbt_project_name = getattr(
+                dbt_objects.dbt_manifest.metadata, "project_name", None
+            )
             for key, manifest_node in manifest_entities.items():
                 try:
                     resource_type = getattr(
@@ -644,6 +648,7 @@ class DbtSource(DbtServiceSource):
                                     catalog_node=catalog_node,
                                 ),
                                 tags=dbt_table_tags_list or [],
+                                dbtSourceProject=dbt_project_name,
                             ),
                         )
                         yield Either(right=data_model_link)

metadata/ingestion/source/database/glue/metadata.py

@@ -406,7 +406,7 @@ class GlueSource(ExternalTableLineageMixin, DatabaseServiceSource):
                 for glue_col in glue_columns:
                     col_name = glue_col["Name"]
                     col_type = glue_col["Type"]
-                    col_comment = glue_col.get("Comment", "")
+                    col_comment = glue_col.get("Comment")
                     col_parameters = glue_col.get("Parameters", {})
 
                     # Check if this is a non-current Iceberg column
@@ -427,7 +427,7 @@ class GlueSource(ExternalTableLineageMixin, DatabaseServiceSource):
                 for glue_col in partition_keys:
                     col_name = glue_col["Name"]
                     col_type = glue_col["Type"]
-                    col_comment = glue_col.get("Comment", "")
+                    col_comment = glue_col.get("Comment")
                     col_parameters = glue_col.get("Parameters", {})
 
                     # Check if this is a non-current Iceberg column

metadata/ingestion/source/database/oracle/connection.py

@@ -48,8 +48,7 @@ from metadata.ingestion.connections.test_connections import test_connection_db_c
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.database.oracle.queries import (
     CHECK_ACCESS_TO_ALL,
-    ORACLE_GET_SCHEMA,
-    ORACLE_GET_STORED_PACKAGES,
+    TEST_ORACLE_GET_STORED_PACKAGES,
 )
 from metadata.utils.constants import THREE_MIN
 from metadata.utils.logger import ingestion_logger
@@ -97,18 +96,9 @@ class OracleConnection(BaseConnection[OracleConnectionConfig, Engine]):
         of a metadata workflow or during an Automation Workflow
         """
 
-        def test_oracle_package_access(engine):
-            try:
-                schema_name = engine.execute(ORACLE_GET_SCHEMA).scalar()
-                return ORACLE_GET_STORED_PACKAGES.format(schema=schema_name)
-            except Exception as e:
-                raise OraclePackageAccessError(
-                    f"Failed to access Oracle stored packages: {e}"
-                )
-
         test_conn_queries = {
             "CheckAccess": CHECK_ACCESS_TO_ALL,
-            "PackageAccess": test_oracle_package_access(self.client),
+            "PackageAccess": TEST_ORACLE_GET_STORED_PACKAGES,
         }
 
         return test_connection_db_common(
@@ -225,9 +215,3 @@ class OracleConnection(BaseConnection[OracleConnectionConfig, Engine]):
             return url
 
         raise ValueError(f"Unknown connection type {connection.oracleConnectionType}")
-
-
-class OraclePackageAccessError(Exception):
-    """
-    Raised when unable to access Oracle stored packages
-    """

metadata/ingestion/source/database/oracle/queries.py

@@ -95,12 +95,7 @@ WHERE
     type = 'PROCEDURE' and owner = '{schema}'
 """
 )
-ORACLE_GET_SCHEMA = """
-    SELECT USERNAME AS SCHEMA_NAME 
-    FROM ALL_USERS 
-    WHERE ROWNUM = 1 
-    ORDER BY USERNAME
-"""
+
 ORACLE_GET_STORED_PACKAGES = textwrap.dedent(
     """
 SELECT
@@ -115,6 +110,30 @@ FROM
 WHERE TYPE IN ('PACKAGE', 'PACKAGE BODY') AND owner = '{schema}'
 """
 )
+
+TEST_ORACLE_GET_STORED_PACKAGES = textwrap.dedent(
+    """
+SELECT
+    OWNER,
+    NAME,
+    LINE,
+    TEXT,
+    'StoredPackage' as procedure_type
+FROM
+    DBA_SOURCE
+WHERE
+    TYPE IN ('PACKAGE', 'PACKAGE BODY')
+    AND owner = (
+        SELECT
+            USERNAME
+        FROM
+            ALL_USERS
+        WHERE
+            ROWNUM = 1
+    )
+"""
+)
+
 CHECK_ACCESS_TO_ALL = "SELECT table_name FROM DBA_TABLES where ROWNUM < 2"
 ORACLE_GET_STORED_PROCEDURE_QUERIES = textwrap.dedent(
     """

metadata/ingestion/source/database/stored_procedures_mixin.py

@@ -168,6 +168,9 @@ class StoredProcedureLineageMixin(ABC):
 
         # Yield the ProcedureAndQuery for filtered stored procedure
         for query_by_procedure in queries:
+            if not query_by_procedure.procedure_name:
+                continue
+
             procedure_name = query_by_procedure.procedure_name.lower()
             queries_count_per_procedure[procedure_name] += 1
 

metadata/ingestion/source/database/trino/metadata.py

@@ -35,7 +35,10 @@ from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.connections import get_connection
 from metadata.ingestion.source.database.column_type_parser import ColumnTypeParser
 from metadata.ingestion.source.database.common_db_source import CommonDbSourceService
-from metadata.ingestion.source.database.trino.queries import TRINO_TABLE_COMMENTS
+from metadata.ingestion.source.database.trino.queries import (
+    TRINO_TABLE_COMMENTS,
+    TRINO_VIEW_DEFINITION,
+)
 from metadata.utils import fqn
 from metadata.utils.filters import filter_by_database
 from metadata.utils.logger import ingestion_logger
@@ -168,9 +171,43 @@ def get_table_comment(  # pylint: disable=unused-argument
         raise
 
 
+def get_view_definition(
+    self, connection: Connection, view_name: str, schema: str = None, **kw
+) -> Optional[str]:
+    """
+    Get the view definition using SHOW CREATE VIEW for Trino
+
+    Default implementation from sqlalchemy uses view_definition column value
+    from "information_schema"."views" view, which does not return the full definition
+    of view. Hence, we should use SHOW CREATE VIEW statement to get full view definition.
+    """
+    catalog_name = self._get_default_catalog_name(  # pylint: disable=protected-access
+        connection
+    )
+    schema = schema or self._get_default_schema_name(
+        connection
+    )  # pylint: disable=protected-access
+    if schema is None:
+        raise exc.NoSuchTableError("schema is required")
+
+    if catalog_name:
+        full_view_name = f"{catalog_name}.{schema}.{view_name}"
+    else:
+        full_view_name = f"{schema}.{view_name}"
+
+    try:
+        # Use SHOW CREATE VIEW to get the full DDL
+        query = TRINO_VIEW_DEFINITION.format(view_name=full_view_name)
+        res = connection.execute(sql.text(query))
+        return res.scalar()
+    except Exception:
+        logger.warning(f"Could not get view definition for view [{full_view_name}]")
+
+
 TrinoDialect._get_columns = _get_columns  # pylint: disable=protected-access
 TrinoDialect.get_all_table_comments = get_all_table_comments
 TrinoDialect.get_table_comment = get_table_comment
+TrinoDialect.get_view_definition = get_view_definition
 
 
 class TrinoSource(CommonDbSourceService):
@@ -226,9 +263,11 @@ class TrinoSource(CommonDbSourceService):
                     )
                     if filter_by_database(
                         self.source_config.databaseFilterPattern,
-                        database_fqn
-                        if self.source_config.useFqnForFiltering
-                        else new_catalog,
+                        (
+                            database_fqn
+                            if self.source_config.useFqnForFiltering
+                            else new_catalog
+                        ),
                     ):
                         self.status.filter(database_fqn, "Database Filtered Out")
                         continue

metadata/ingestion/source/database/trino/queries.py

@@ -46,3 +46,7 @@ TRINO_TABLE_COMMENTS = textwrap.dedent(
 TRINO_GET_DATABASE = """
 SHOW CATALOGS
 """
+
+TRINO_VIEW_DEFINITION = """
+SHOW CREATE VIEW {view_name}
+"""

metadata/ingestion/source/storage/storage_service.py

@@ -274,6 +274,7 @@ class StorageServiceSource(TopologyRunnerMixin, Source, ABC):
                 isPartitioned=entry.isPartitioned,
                 partitionColumns=entry.partitionColumns,
                 separator=entry.separator,
+                depth=entry.depth,
             )
             for entry in manifest.entries
             if entry.containerName == container_name

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

@@ -13,11 +13,13 @@
 Interfaces with database for all database engine
 supporting sqlalchemy abstraction layer
 """
+from copy import deepcopy
 from typing import List, Type, cast
 
 from sqlalchemy import Column, inspect
 
 from metadata.generated.schema.entity.data.table import SystemProfile
+from metadata.generated.schema.security.credentials.gcpValues import SingleProjectId
 from metadata.profiler.interface.sqlalchemy.profiler_interface import (
     SQAProfilerInterface,
 )
@@ -27,6 +29,7 @@ from metadata.profiler.metrics.system.bigquery.system import (
 from metadata.profiler.metrics.system.system import System
 from metadata.profiler.processor.runner import QueryRunner
 from metadata.utils.logger import profiler_interface_registry_logger
+from metadata.utils.ssl_manager import get_ssl_connection
 
 logger = profiler_interface_registry_logger()
 
@@ -34,6 +37,19 @@ logger = profiler_interface_registry_logger()
 class BigQueryProfilerInterface(SQAProfilerInterface):
     """BigQuery profiler interface"""
 
+    def create_session(self):
+        connection_config = deepcopy(self.service_connection_config)
+        # Create a modified connection for BigQuery with the correct project ID
+        if (
+            hasattr(connection_config.credentials.gcpConfig, "projectId")
+            and self.table_entity.database
+        ):
+            connection_config.credentials.gcpConfig.projectId = SingleProjectId(
+                root=self.table_entity.database.name
+            )
+            self.connection = get_ssl_connection(connection_config)
+        return super().create_session()
+
     def _compute_system_metrics(
         self,
         metrics: Type[System],
@@ -49,6 +65,7 @@ class BigQueryProfilerInterface(SQAProfilerInterface):
             session=self.session,
             runner=runner,
             usage_location=self.service_connection_config.usageLocation,
+            billing_project_id=self.service_connection_config.billingProjectId,
         )
         return instance.get_system_metrics()
 

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

@@ -1,6 +1,6 @@
 """BigQuery system metric source"""
 
-from typing import List
+from typing import List, Optional
 
 from pydantic import TypeAdapter
 from sqlalchemy.orm import Session
@@ -30,12 +30,14 @@ class BigQuerySystemMetricsComputer(SystemMetricsComputer, CacheProvider):
         session: Session,
         runner: QueryRunner,
         usage_location: str,
+        billing_project_id: Optional[str] = None,
     ):
         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
+        self.billing_project_id = billing_project_id or self.project_id
 
     def get_deletes(self) -> List[SystemProfile]:
         return self.get_system_profile(
@@ -116,6 +118,7 @@ class BigQuerySystemMetricsComputer(SystemMetricsComputer, CacheProvider):
             usage_location=usage_location,
             project_id=project_id,
             dataset_id=dataset_id,
+            billing_project_id=self.billing_project_id,
         )
 
     @staticmethod

metadata/profiler/orm/functions/table_metric_computer.py

@@ -304,8 +304,7 @@ class BigQueryTableMetricComputer(BaseTableMetricComputer):
         ]
 
         where_clause = [
-            Column("project_id")
-            == self.conn_config.credentials.gcpConfig.projectId.root,
+            Column("project_id") == self._entity.database.name,
             Column("table_schema") == self.schema_name,
             Column("table_name") == self.table_name,
         ]
@@ -338,17 +337,14 @@ class BigQueryTableMetricComputer(BaseTableMetricComputer):
             *self._get_col_names_and_count(),
         ]
         where_clause = [
-            Column("project_id")
-            == self.conn_config.credentials.gcpConfig.projectId.root,
+            Column("project_id") == self._entity.database.name,
             Column("dataset_id") == self.schema_name,
             Column("table_id") == self.table_name,
         ]
         schema = (
-            self.schema_name.startswith(
-                f"{self.conn_config.credentials.gcpConfig.projectId.root}."
-            )
+            self.schema_name.startswith(f"{self._entity.database.name}.")
             and self.schema_name
-            or f"{self.conn_config.credentials.gcpConfig.projectId.root}.{self.schema_name}"
+            or f"{self._entity.database.name}.{self.schema_name}"
         )
         query = self._build_query(
             columns,