openmetadata-ingestion 1.7.0.0rc2__py3-none-any.whl → 1.7.1.0__py3-none-any.whl

metadata/profiler/interface/sqlalchemy/profiler_interface.py

@@ -18,6 +18,7 @@ supporting sqlalchemy abstraction layer
 import concurrent.futures
 import math
 import threading
+import time
 import traceback
 from collections import defaultdict
 from datetime import datetime
@@ -397,43 +398,72 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
             f"Running profiler for {metric_func.table.__tablename__} on thread {threading.current_thread()}"
         )
         Session = self.session_factory  # pylint: disable=invalid-name
-        with Session() as session:
-            self.set_session_tag(session)
-            self.set_catalog(session)
-            runner = self._create_thread_safe_runner(session, metric_func.column)
-            row = None
-            try:
-                row = self._get_metric_fn[metric_func.metric_type.value](
-                    metric_func.metrics,
-                    runner=runner,
-                    session=session,
-                    column=metric_func.column,
-                    sample=runner.dataset,
-                )
-                if isinstance(row, dict):
-                    row = self._validate_nulls(row)
-                if isinstance(row, list):
-                    row = [
-                        self._validate_nulls(r) if isinstance(r, dict) else r
-                        for r in row
-                    ]
-
-            except Exception as exc:
-                error = (
-                    f"{metric_func.column if metric_func.column is not None else metric_func.table.__tablename__} "
-                    f"metric_type.value: {exc}"
-                )
-                logger.error(error)
-                self.status.failed_profiler(error, traceback.format_exc())
-
-            if metric_func.column is not None:
-                column = metric_func.column.name
-                self.status.scanned(f"{metric_func.table.__tablename__}.{column}")
-            else:
-                self.status.scanned(metric_func.table.__tablename__)
-                column = None
+        max_retries = 3
+        retry_count = 0
+        initial_backoff = 5
+        max_backoff = 30
+        row = None
+
+        while retry_count < max_retries:
+            with Session() as session:
+                self.set_session_tag(session)
+                self.set_catalog(session)
+                runner = self._create_thread_safe_runner(session, metric_func.column)
+                try:
+                    row = self._get_metric_fn[metric_func.metric_type.value](
+                        metric_func.metrics,
+                        runner=runner,
+                        session=session,
+                        column=metric_func.column,
+                        sample=runner.dataset,
+                    )
+                    if isinstance(row, dict):
+                        row = self._validate_nulls(row)
+                    if isinstance(row, list):
+                        row = [
+                            self._validate_nulls(r) if isinstance(r, dict) else r
+                            for r in row
+                        ]
+
+                    # On success, log the scan and break out of the retry loop
+                    if metric_func.column is not None:
+                        column = metric_func.column.name
+                        self.status.scanned(
+                            f"{metric_func.table.__tablename__}.{column}"
+                        )
+                    else:
+                        self.status.scanned(metric_func.table.__tablename__)
+                        column = None
+
+                    return row, column, metric_func.metric_type.value
+
+                except Exception as exc:
+                    dialect = session.get_bind().dialect
+                    if dialect.is_disconnect(exc, session.get_bind(), None):
+                        retry_count += 1
+                        if retry_count < max_retries:
+                            backoff = min(
+                                initial_backoff * (2 ** (retry_count - 1)), max_backoff
+                            )
+                            logger.debug(
+                                f"Connection error detected, retrying ({retry_count}/{max_retries}) "
+                                f"after {backoff:.2f} seconds..."
+                            )
+                            session.rollback()
+                            time.sleep(backoff)
+                            continue
+                        logger.error(
+                            f"Max retries ({max_retries}) exceeded for disconnection"
+                        )
+                    error = (
+                        f"{metric_func.column if metric_func.column is not None else metric_func.table.__tablename__} "
+                        f"metric_type.value: {exc}"
+                    )
+                    logger.error(error)
+                    self.status.failed_profiler(error, traceback.format_exc())
 
-            return row, column, metric_func.metric_type.value
+        # If we've exhausted all retries without success, return a tuple of None values
+        return None, None, None
 
     @staticmethod
     def _validate_nulls(row: Dict[str, Any]) -> Dict[str, Any]:

metadata/profiler/processor/runner.py

@@ -23,7 +23,10 @@ from sqlalchemy.orm import DeclarativeMeta, Query, Session
 from sqlalchemy.orm.util import AliasedClass
 
 from metadata.utils.logger import query_runner_logger
-from metadata.utils.sqa_utils import get_query_filter_for_runner
+from metadata.utils.sqa_utils import (
+    get_query_filter_for_runner,
+    get_query_group_by_for_runner,
+)
 
 logger = query_runner_logger()
 
@@ -88,6 +91,11 @@ class QueryRunner:
         """Table name attribute access"""
         return self._session
 
+    @property
+    def dialect(self) -> str:
+        """Dialect attribute access"""
+        return self._session.get_bind().dialect.name
+
     def _build_query(self, *entities, **kwargs) -> Query:
         """Build query object
 
@@ -106,11 +114,15 @@ class QueryRunner:
             **kwargs: kwargs to pass to the query
         """
         filter_ = get_query_filter_for_runner(kwargs)
+        group_by_ = get_query_group_by_for_runner(kwargs)
 
         query = self._build_query(*entities, **kwargs).select_from(self._dataset)
 
         if filter_ is not None:
-            return query.filter(filter_)
+            query = query.filter(filter_)
+
+        if group_by_ is not None:
+            query = query.group_by(*group_by_)
 
         return query
 
@@ -122,7 +134,7 @@ class QueryRunner:
             **kwargs: kwargs to pass to the query
         """
         filter_ = get_query_filter_for_runner(kwargs)
-
+        group_by_ = get_query_group_by_for_runner(kwargs)
         user_query = self._session.query(self._dataset).from_statement(
             text(f"{self.profile_sample_query}")
         )
@@ -130,7 +142,10 @@ class QueryRunner:
         query = self._build_query(*entities, **kwargs).select_from(user_query)
 
         if filter_ is not None:
-            return query.filter(filter_)
+            query = query.filter(filter_)
+
+        if group_by_ is not None:
+            query = query.group_by(*group_by_)
 
         return query
 
@@ -143,13 +158,17 @@ class QueryRunner:
             **kwargs: kwargs to pass to the query
         """
         filter_ = get_query_filter_for_runner(kwargs)
+        group_by_ = get_query_group_by_for_runner(kwargs)
 
         if self.profile_sample_query:
             return self._select_from_user_query(*entities, **kwargs).first()
         query = self._build_query(*entities, **kwargs).select_from(self.table)
 
         if filter_ is not None:
-            return query.filter(filter_).first()
+            query = query.filter(filter_)
+
+        if group_by_ is not None:
+            query = query.group_by(*group_by_)
 
         return query.first()
 
@@ -162,6 +181,7 @@ class QueryRunner:
             **kwargs: kwargs to pass to the query
         """
         filter_ = get_query_filter_for_runner(kwargs)
+        group_by_ = get_query_group_by_for_runner(kwargs)
 
         if self.profile_sample_query:
             return self._select_from_user_query(*entities, **kwargs).all()
@@ -169,7 +189,10 @@ class QueryRunner:
         query = self._build_query(*entities, **kwargs).select_from(self.table)
 
         if filter_ is not None:
-            return query.filter(filter_).all()
+            query = query.filter(filter_)
+
+        if group_by_ is not None:
+            query = query.group_by(*group_by_)
 
         return query.all()
 

metadata/profiler/source/database/bigquery/profiler_source.py

@@ -13,8 +13,6 @@
 Bigquery Profiler source
 """
 
-from copy import deepcopy
-
 from metadata.generated.schema.entity.data.database import Database
 from metadata.generated.schema.entity.services.connections.database.bigQueryConnection import (
     BigQueryConnection,
@@ -22,12 +20,8 @@ from metadata.generated.schema.entity.services.connections.database.bigQueryConn
 from metadata.generated.schema.metadataIngestion.workflow import (
     OpenMetadataWorkflowConfig,
 )
-from metadata.generated.schema.security.credentials.gcpValues import (
-    GcpCredentialsValues,
-    MultipleProjectId,
-    SingleProjectId,
-)
 from metadata.profiler.source.database.base.profiler_source import ProfilerSource
+from metadata.utils.bigquery_utils import copy_service_config
 
 
 class BigQueryProfilerSource(ProfilerSource):
@@ -46,16 +40,4 @@ class BigQueryProfilerSource(ProfilerSource):
         Returns:
             DatabaseConnection
         """
-        config_copy: BigQueryConnection = deepcopy(
-            config.source.serviceConnection.root.config  # type: ignore
-        )
-
-        if isinstance(config_copy.credentials.gcpConfig, GcpCredentialsValues):
-            if isinstance(
-                config_copy.credentials.gcpConfig.projectId, MultipleProjectId
-            ):
-                config_copy.credentials.gcpConfig.projectId = SingleProjectId(
-                    database.name.root
-                )
-
-        return config_copy
+        return copy_service_config(config, database.name.root)

metadata/profiler/source/database/mssql/profiler_source.py

@@ -0,0 +1,86 @@
+"""Extend the ProfilerSource class to add support for MSSQL is_disconnect SQA method"""
+from metadata.generated.schema.configuration.profilerConfiguration import (
+    ProfilerConfiguration,
+)
+from metadata.generated.schema.entity.data.database import Database
+from metadata.generated.schema.entity.services.connections.database.mssqlConnection import (
+    MssqlScheme,
+)
+from metadata.generated.schema.metadataIngestion.workflow import (
+    OpenMetadataWorkflowConfig,
+)
+from metadata.ingestion.ometa.ometa_api import OpenMetadata
+from metadata.profiler.source.database.base.profiler_source import ProfilerSource
+
+
+def is_disconnect(is_disconnect_original):
+    """Wrapper to add custom is_disconnect method for the MSSQL dialects"""
+
+    def inner_is_disconnect(self, e, connection, cursor):
+        """is_disconnect method for the MSSQL dialects"""
+        error_str = str(e)
+
+        mssql_disconnect_codes = [
+            "08S01",  # Communication link failure
+            "08001",  # Cannot connect
+            "HY000",  # General error often used for connection issues
+        ]
+
+        mssql_disconnect_messages = [
+            "Server closed connection",
+            "ClosedConnectionError",
+            "Connection is closed",
+            "Connection reset by peer",
+            "Timeout expired",
+            "Socket closed",
+        ]
+
+        if any(code in error_str for code in mssql_disconnect_codes) or any(
+            message in error_str for message in mssql_disconnect_messages
+        ):
+            return True
+
+        # If none of our custom checks match, fall back to SQLAlchemy's built-in detection
+        return is_disconnect_original(self, e, connection, cursor)
+
+    return inner_is_disconnect
+
+
+class MssqlProfilerSource(ProfilerSource):
+    """MSSQL Profiler source"""
+
+    def __init__(
+        self,
+        config: OpenMetadataWorkflowConfig,
+        database: Database,
+        ometa_client: OpenMetadata,
+        global_profiler_config: ProfilerConfiguration,
+    ):
+        super().__init__(config, database, ometa_client, global_profiler_config)
+        self.set_is_disconnect(config)
+
+    def set_is_disconnect(self, config: OpenMetadataWorkflowConfig):
+        """Set the is_disconnect method based on the configured connection scheme"""
+        # pylint: disable=import-outside-toplevel
+
+        # Get the configured scheme from the source connection
+        scheme = config.source.serviceConnection.root.config.scheme
+
+        # Set the appropriate is_disconnect method based on the scheme
+        if scheme == MssqlScheme.mssql_pytds:
+            from sqlalchemy_pytds.dialect import MSDialect_pytds
+
+            original_is_disconnect = MSDialect_pytds.is_disconnect
+            MSDialect_pytds.is_disconnect = is_disconnect(original_is_disconnect)
+        elif scheme == MssqlScheme.mssql_pyodbc:
+            from sqlalchemy.dialects.mssql.pyodbc import MSDialect_pyodbc
+
+            original_is_disconnect = MSDialect_pyodbc.is_disconnect
+            MSDialect_pyodbc.is_disconnect = is_disconnect(original_is_disconnect)
+        elif scheme == MssqlScheme.mssql_pymssql:
+            from sqlalchemy.dialects.mssql.pymssql import MSDialect_pymssql
+
+            original_is_disconnect = MSDialect_pymssql.is_disconnect
+            MSDialect_pymssql.is_disconnect = is_disconnect(original_is_disconnect)
+        else:
+            raise ValueError(f"Unsupported MSSQL scheme: {scheme}")

metadata/profiler/source/fetcher/profiler_source_factory.py

@@ -21,6 +21,9 @@ from metadata.generated.schema.entity.services.connections.database.bigQueryConn
 from metadata.generated.schema.entity.services.connections.database.databricksConnection import (
     DatabricksType,
 )
+from metadata.generated.schema.entity.services.connections.database.mssqlConnection import (
+    MssqlType,
+)
 from metadata.profiler.source.profiler_source_interface import ProfilerSourceInterface
 
 
@@ -79,10 +82,20 @@ class ProfilerSourceFactory:
 
         return DataBricksProfilerSource
 
+    @staticmethod
+    def mssql() -> Type[ProfilerSourceInterface]:
+        """Lazy loading of the MSSQL source"""
+        from metadata.profiler.source.database.mssql.profiler_source import (
+            MssqlProfilerSource,
+        )
+
+        return MssqlProfilerSource
+
 
 source = {
     BigqueryType.BigQuery.value.lower(): ProfilerSourceFactory.bigquery,
     DatabricksType.Databricks.value.lower(): ProfilerSourceFactory.databricks,
+    MssqlType.Mssql.value.lower(): ProfilerSourceFactory.mssql,
 }
 
 profiler_source_factory = ProfilerSourceFactory()

metadata/readers/dataframe/json.py

@@ -35,7 +35,11 @@ def _get_json_text(key: str, text: bytes, decode: bool) -> Union[str, bytes]:
         with zipfile.ZipFile(io.BytesIO(text)) as zip_file:
             processed_text = zip_file.read(zip_file.infolist()[0])
     if decode:
-        return processed_text.decode(UTF_8) if isinstance(text, bytes) else text
+        return (
+            processed_text.decode(UTF_8, errors="ignore")
+            if isinstance(text, bytes)
+            else text
+        )
     return processed_text
 
 

metadata/readers/dataframe/parquet.py

@@ -68,8 +68,16 @@ class ParquetDataFrameReader(DataFrameReader):
         from pyarrow.parquet import ParquetDataset
 
         client_kwargs = {
-            "endpoint_override": str(self.config_source.securityConfig.endPointURL),
-            "region": self.config_source.securityConfig.awsRegion,
+            "endpoint_override": (
+                str(self.config_source.securityConfig.endPointURL)
+                if self.config_source.securityConfig.endPointURL
+                else None
+            ),
+            "region": (
+                self.config_source.securityConfig.awsRegion
+                if self.config_source.securityConfig.awsRegion
+                else None
+            ),
             "access_key": self.config_source.securityConfig.awsAccessKeyId,
             "session_token": self.config_source.securityConfig.awsSessionToken,
             "role_arn": self.config_source.securityConfig.assumeRoleArn,

metadata/readers/dataframe/reader_factory.py

@@ -39,6 +39,10 @@ class SupportedTypes(Enum):
     TSV = "tsv"
     AVRO = "avro"
     PARQUET = "parquet"
+    PARQUET_PQ = "pq"
+    PARQUET_PQT = "pqt"
+    PARQUET_PARQ = "parq"
+    PARQUET_SNAPPY = "parquet.snappy"
     JSON = "json"
     JSONGZ = "json.gz"
     JSONZIP = "json.zip"
@@ -52,6 +56,10 @@ DF_READER_MAP = {
     SupportedTypes.TSV.value: TSVDataFrameReader,
     SupportedTypes.AVRO.value: AvroDataFrameReader,
     SupportedTypes.PARQUET.value: ParquetDataFrameReader,
+    SupportedTypes.PARQUET_PQ.value: ParquetDataFrameReader,
+    SupportedTypes.PARQUET_PQT.value: ParquetDataFrameReader,
+    SupportedTypes.PARQUET_PARQ.value: ParquetDataFrameReader,
+    SupportedTypes.PARQUET_SNAPPY.value: ParquetDataFrameReader,
     SupportedTypes.JSON.value: JSONDataFrameReader,
     SupportedTypes.JSONGZ.value: JSONDataFrameReader,
     SupportedTypes.JSONZIP.value: JSONDataFrameReader,

metadata/sampler/processor.py

@@ -17,6 +17,9 @@ from typing import Optional, cast
 
 from metadata.generated.schema.entity.data.database import Database
 from metadata.generated.schema.entity.data.table import Table
+from metadata.generated.schema.entity.services.connections.database.bigQueryConnection import (
+    BigQueryConnection,
+)
 from metadata.generated.schema.entity.services.databaseService import DatabaseConnection
 from metadata.generated.schema.entity.services.ingestionPipelines.status import (
     StackTraceError,
@@ -38,6 +41,7 @@ from metadata.profiler.source.metadata import ProfilerSourceAndEntity
 from metadata.sampler.config import get_config_for_table
 from metadata.sampler.models import SampleConfig, SampleData, SamplerResponse
 from metadata.sampler.sampler_interface import SamplerInterface
+from metadata.utils.bigquery_utils import copy_service_config
 from metadata.utils.profiler_utils import get_context_entities
 from metadata.utils.service_spec.service_spec import import_sampler_class
 
@@ -95,7 +99,7 @@ class SamplerProcessor(Processor):
                 data=sampler_interface.generate_sample_data(),
                 store=self.source_config.storeSampleData,
             )
-
+            sampler_interface.close()
             return Either(
                 right=SamplerResponse(
                     table=entity,
@@ -133,6 +137,9 @@ class SamplerProcessor(Processor):
         Returns:
             DatabaseService.__config__
         """
+        if isinstance(config.source.serviceConnection.root.config, BigQueryConnection):
+            return copy_service_config(config, database.name.root)
+
         config_copy = deepcopy(
             config.source.serviceConnection.root.config  # type: ignore
         )

metadata/sampler/sampler_interface.py

@@ -245,3 +245,6 @@ class SamplerInterface(ABC):
             logger.debug(traceback.format_exc())
             logger.warning(f"Error fetching sample data: {err}")
             raise err
+
+    def close(self):
+        """Default noop"""

metadata/sampler/sqlalchemy/bigquery/sampler.py

@@ -35,6 +35,11 @@ from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.sampler.models import SampleConfig
 from metadata.sampler.sqlalchemy.sampler import SQASampler
 from metadata.utils.constants import SAMPLE_DATA_DEFAULT_COUNT
+from metadata.utils.logger import profiler_interface_registry_logger
+
+logger = profiler_interface_registry_logger()
+
+RANDOM_LABEL = "random"
 
 
 class BigQuerySampler(SQASampler):

metadata/sampler/sqlalchemy/sampler.py

@@ -13,7 +13,6 @@ Helper module to handle data sampling
 for the profiler
 """
 import hashlib
-import traceback
 from typing import List, Optional, Union, cast
 
 from sqlalchemy import Column, inspect, text
@@ -100,16 +99,16 @@ class SQASampler(SamplerInterface, SQAInterfaceMixin):
         """
         # only sample the column if we are computing a column metric to limit the amount of data scaned
         selectable = self.set_tablesample(self.raw_dataset.__table__)
+        client = self.get_client()
 
         entity = selectable if column is None else selectable.c.get(column.key)
-        with self.get_client() as client:
-            if label is not None:
-                query = client.query(entity, label)
-            else:
-                query = client.query(entity)
+        if label is not None:
+            query = client.query(entity, label)
+        else:
+            query = client.query(entity)
 
-            if self.partition_details:
-                query = self.get_partitioned_query(query)
+        if self.partition_details:
+            query = self.get_partitioned_query(query)
         return query
 
     def get_sampler_table_name(self) -> str:
@@ -125,19 +124,18 @@ class SQASampler(SamplerInterface, SQAInterfaceMixin):
 
     def get_sample_query(self, *, column=None) -> Query:
         """get query for sample data"""
+        client = self.get_client()
         if self.sample_config.profileSampleType == ProfileSampleType.PERCENTAGE:
             rnd = self._base_sample_query(
                 column,
                 (ModuloFn(RandomNumFn(), 100)).label(RANDOM_LABEL),
             ).cte(f"{self.get_sampler_table_name()}_rnd")
-            with self.get_client() as client:
-                session_query = client.query(rnd)
+            session_query = client.query(rnd)
             return session_query.where(
                 rnd.c.random <= self.sample_config.profileSample
             ).cte(f"{self.get_sampler_table_name()}_sample")
 
-        with self.get_client() as client:
-            table_query = client.query(self.raw_dataset)
+        table_query = client.query(self.raw_dataset)
         session_query = self._base_sample_query(
             column,
             (ModuloFn(RandomNumFn(), table_query.count())).label(RANDOM_LABEL)
@@ -198,31 +196,20 @@ class SQASampler(SamplerInterface, SQAInterfaceMixin):
                 for col in inspect(ds).c
                 if col.name != RANDOM_LABEL and col.name in names
             ]
+
         with self.get_client() as client:
-            try:
-                sqa_sample = (
-                    client.query(*sqa_columns)
-                    .select_from(ds)
-                    .limit(self.sample_limit)
-                    .all()
-                )
-            except Exception:
-                logger.debug(
-                    "Cannot fetch sample data with random sampling. Falling back to 100 rows."
-                )
-                logger.debug(traceback.format_exc())
-                sqa_columns = list(inspect(self.raw_dataset).c)
-                sqa_sample = (
-                    client.query(*sqa_columns)
-                    .select_from(self.raw_dataset)
-                    .limit(100)
-                    .all()
-                )
-            return TableData(
-                columns=[column.name for column in sqa_columns],
-                rows=[list(row) for row in sqa_sample],
+            sqa_sample = (
+                client.query(*sqa_columns)
+                .select_from(ds)
+                .limit(self.sample_limit)
+                .all()
             )
 
+        return TableData(
+            columns=[column.name for column in sqa_columns],
+            rows=[list(row) for row in sqa_sample],
+        )
+
     def _fetch_sample_data_from_user_query(self) -> TableData:
         """Returns a table data object using results from query execution"""
         if not is_safe_sql_query(self.sample_query):
@@ -246,10 +233,11 @@ class SQASampler(SamplerInterface, SQAInterfaceMixin):
 
         stmt = text(f"{self.sample_query}")
         stmt = stmt.columns(*list(inspect(self.raw_dataset).c))
-        with self.get_client() as client:
-            return client.query(stmt.subquery()).cte(
-                f"{self.get_sampler_table_name()}_user_sampled"
-            )
+        return (
+            self.get_client()
+            .query(stmt.subquery())
+            .cte(f"{self.get_sampler_table_name()}_user_sampled")
+        )
 
     def _partitioned_table(self) -> Query:
         """Return the Query object for partitioned tables"""
@@ -266,9 +254,13 @@ class SQASampler(SamplerInterface, SQAInterfaceMixin):
         )
         if query is not None:
             return query.filter(partition_filter)
-        with self.get_client() as client:
-            return client.query(self.raw_dataset).filter(partition_filter)
+        return self.get_client().query(self.raw_dataset).filter(partition_filter)
 
     def get_columns(self):
         """get columns from entity"""
         return list(inspect(self.raw_dataset).c)
+
+    def close(self):
+        """Close the connection"""
+        self.get_client().close()
+        self.connection.pool.dispose()

metadata/utils/bigquery_utils.py

@@ -13,10 +13,22 @@
 Utils module of BigQuery
 """
 
+from copy import deepcopy
 from typing import List, Optional
 
 from google.cloud import bigquery
 
+from metadata.generated.schema.entity.services.connections.database.bigQueryConnection import (
+    BigQueryConnection,
+)
+from metadata.generated.schema.metadataIngestion.workflow import (
+    OpenMetadataWorkflowConfig,
+)
+from metadata.generated.schema.security.credentials.gcpValues import (
+    GcpCredentialsValues,
+    MultipleProjectId,
+    SingleProjectId,
+)
 from metadata.utils.credentials import (
     get_gcp_default_credentials,
     get_gcp_impersonate_credentials,
@@ -56,3 +68,26 @@ def get_bigquery_client(
     return bigquery.Client(
         credentials=credentials, project=project_id, location=location
     )
+
+
+def copy_service_config(
+    config: OpenMetadataWorkflowConfig, database_name: str
+) -> BigQueryConnection:
+    """Handles multiple project id in the service config and replace it with the database name
+
+    Args:
+        config (OpenMetadataWorkflowConfig): openmetadata workflow config
+        database_name (str): database name
+
+    Returns:
+        BigQueryConnection: bigquery connection
+    """
+    config_copy: BigQueryConnection = deepcopy(
+        config.source.serviceConnection.root.config  # type: ignore
+    )
+
+    if isinstance(config_copy.credentials.gcpConfig, GcpCredentialsValues):
+        if isinstance(config_copy.credentials.gcpConfig.projectId, MultipleProjectId):
+            config_copy.credentials.gcpConfig.projectId = SingleProjectId(database_name)
+
+    return config_copy