openmetadata-ingestion 1.4.7.2__py3-none-any.whl → 1.5.0.0__py3-none-any.whl

metadata/profiler/processor/core.py

@@ -40,6 +40,7 @@ from metadata.generated.schema.settings.settings import Settings
 from metadata.generated.schema.tests.customMetric import (
     CustomMetric as CustomMetricEntity,
 )
+from metadata.generated.schema.type.basic import Timestamp
 from metadata.profiler.api.models import ProfilerResponse, ThreadPoolMetrics
 from metadata.profiler.interface.profiler_interface import ProfilerInterface
 from metadata.profiler.metrics.core import (
@@ -51,6 +52,7 @@ from metadata.profiler.metrics.core import (
     TMetric,
 )
 from metadata.profiler.metrics.static.row_count import RowCount
+from metadata.profiler.orm.functions.table_metric_computer import CREATE_DATETIME
 from metadata.profiler.orm.registry import NOT_COMPUTE
 from metadata.profiler.processor.metric_filter import MetricFilter
 from metadata.profiler.processor.sample_data_handler import upload_sample_data
@@ -105,7 +107,7 @@ class Profiler(Generic[TMetric]):
         self.include_columns = include_columns
         self.exclude_columns = exclude_columns
         self._metrics = metrics
-        self._profile_date = int(datetime.now(tz=timezone.utc).timestamp() * 1000)
+        self._profile_ts = Timestamp(int(datetime.now().timestamp() * 1000))
         self.profile_sample_config = self.profiler_interface.profile_sample_config
 
         self.metric_filter = MetricFilter(
@@ -150,8 +152,8 @@ class Profiler(Generic[TMetric]):
         return self._get_included_columns()
 
     @property
-    def profile_date(self) -> datetime:
-        return self._profile_date
+    def profile_ts(self) -> Timestamp:
+        return self._profile_ts
 
     @property
     def columns(self) -> List[Column]:
@@ -218,7 +220,7 @@ class Profiler(Generic[TMetric]):
                     return
 
         raise RuntimeError(
-            f"No profile data computed for {self.profiler_interface.table_entity.fullyQualifiedName.__root__}"
+            f"No profile data computed for {self.profiler_interface.table_entity.fullyQualifiedName.root}"
         )
 
     def get_custom_metrics(
@@ -240,7 +242,7 @@ class Profiler(Generic[TMetric]):
             (
                 clmn
                 for clmn in self.profiler_interface.table_entity.columns
-                if clmn.name.__root__ == column_name
+                if clmn.name.root == column_name
             ),
             None,
         )
@@ -486,7 +488,7 @@ class Profiler(Generic[TMetric]):
 
         if self.source_config.computeMetrics:
             logger.debug(
-                f"Computing profile metrics for {self.profiler_interface.table_entity.fullyQualifiedName.__root__}..."
+                f"Computing profile metrics for {self.profiler_interface.table_entity.fullyQualifiedName.root}..."
             )
             self.compute_metrics()
 
@@ -517,7 +519,7 @@ class Profiler(Generic[TMetric]):
         try:
             logger.debug(
                 "Fetching sample data for "
-                f"{self.profiler_interface.table_entity.fullyQualifiedName.__root__}..."  # type: ignore
+                f"{self.profiler_interface.table_entity.fullyQualifiedName.root}..."  # type: ignore
             )
             table_data = self.profiler_interface.fetch_sample_data(
                 self.table, self.columns
@@ -568,22 +570,26 @@ class Profiler(Generic[TMetric]):
                     **self.column_results.get(
                         col.name
                         if not isinstance(col.name, ColumnName)
-                        else col.name.__root__
+                        else col.name.root
                     )
                 )
                 for col in self.columns
                 if self.column_results.get(
-                    col.name
-                    if not isinstance(col.name, ColumnName)
-                    else col.name.__root__
+                    col.name if not isinstance(col.name, ColumnName) else col.name.root
                 )
             ]
 
+            raw_create_date: Optional[datetime] = self._table_results.get(
+                CREATE_DATETIME
+            )
+            if raw_create_date:
+                raw_create_date = raw_create_date.replace(tzinfo=timezone.utc)
+
             table_profile = TableProfile(
-                timestamp=self.profile_date,
+                timestamp=self.profile_ts,
                 columnCount=self._table_results.get("columnCount"),
                 rowCount=self._table_results.get(RowCount.name()),
-                createDateTime=self._table_results.get("createDateTime"),
+                createDateTime=raw_create_date,
                 sizeInByte=self._table_results.get("sizeInBytes"),
                 profileSample=(
                     self.profile_sample_config.profile_sample

metadata/profiler/processor/default.py

@@ -77,9 +77,12 @@ class DefaultProfiler(Profiler):
         include_columns: Optional[List[ColumnProfilerConfig]] = None,
         exclude_columns: Optional[List[str]] = None,
         global_profiler_configuration: Optional[ProfilerConfiguration] = None,
+        db_service=None,
     ):
         _metrics = get_default_metrics(
-            table=profiler_interface.table, ometa_client=profiler_interface.ometa_client
+            table=profiler_interface.table,
+            ometa_client=profiler_interface.ometa_client,
+            db_service=db_service,
         )
 
         super().__init__(

metadata/profiler/processor/processor.py

@@ -43,8 +43,8 @@ class ProfilerProcessor(Processor):
         super().__init__()
 
         self.config = config
-        self.profiler_config = ProfilerProcessorConfig.parse_obj(
-            self.config.processor.dict().get("config")
+        self.profiler_config = ProfilerProcessorConfig.model_validate(
+            self.config.processor.model_dump().get("config")
         )
         self.source_config: DatabaseServiceProfilerPipeline = cast(
             DatabaseServiceProfilerPipeline, self.config.source.sourceConfig.config
@@ -64,8 +64,8 @@ class ProfilerProcessor(Processor):
         except Exception as exc:
             self.status.failed(
                 StackTraceError(
-                    name=record.entity.fullyQualifiedName.__root__,
-                    error=f"Unexpected exception processing entity {record.entity.fullyQualifiedName.__root__}: {exc}",
+                    name=record.entity.fullyQualifiedName.root,
+                    error=f"Unexpected exception processing entity {record.entity.fullyQualifiedName.root}: {exc}",
                     stackTrace=traceback.format_exc(),
                 )
             )

metadata/profiler/processor/sample_data_handler.py

@@ -17,14 +17,13 @@ from datetime import datetime
 from functools import singledispatch
 from io import BytesIO
 
-from pydantic.json import ENCODERS_BY_TYPE
-
 from metadata.clients.aws_client import AWSClient
 from metadata.generated.schema.entity.data.table import Table, TableData
 from metadata.generated.schema.entity.services.connections.connectionBasicType import (
     DataStorageConfig,
 )
 from metadata.generated.schema.security.credentials.awsCredentials import AWSCredentials
+from metadata.ingestion.models.custom_pydantic import ignore_type_decoder
 from metadata.profiler.interface.profiler_interface import ProfilerInterface
 from metadata.utils.helpers import clean_uri
 from metadata.utils.logger import profiler_logger
@@ -62,7 +61,7 @@ def _get_object_key(
         service_name=table.service.name,
         database_name=table.database.name,
         database_schema_name=table.databaseSchema.name,
-        table_name=table.name.__root__,
+        table_name=table.name.root,
     )
     if not overwrite_data:
         file_name = file_name.replace(
@@ -83,11 +82,12 @@ def upload_sample_data(data: TableData, profiler_interface: ProfilerInterface) -
         sample_storage_config: DataStorageConfig = profiler_interface.storage_config
         if not sample_storage_config:
             return
-        ENCODERS_BY_TYPE[bytes] = lambda v: v.decode("utf-8", "ignore")
+        # Ignore any decoding error for byte data
+        ignore_type_decoder(bytes)
         deserialized_data = json.loads(data.json())
         df = pd.DataFrame(
             data=deserialized_data.get("rows", []),
-            columns=[i.__root__ for i in data.columns],
+            columns=[i.root for i in data.columns],
         )
         pq_buffer = BytesIO()
         df.to_parquet(pq_buffer)

metadata/profiler/processor/sampler/nosql/sampler.py

@@ -26,11 +26,13 @@ class NoSQLSampler(SamplerInterface):
         """
         records = self._rdn_sample_from_user_query()
         columns = [
-            SQALikeColumn(name=column.name.__root__, type=column.dataType)
+            SQALikeColumn(name=column.name.root, type=column.dataType)
             for column in self.table.columns
         ]
         rows, cols = self.transpose_records(records, columns)
-        return TableData(rows=rows, columns=[c.name for c in cols])
+        return TableData(
+            rows=[list(map(str, row)) for row in rows], columns=[c.name for c in cols]
+        )
 
     def random_sample(self):
         pass
@@ -40,14 +42,17 @@ class NoSQLSampler(SamplerInterface):
             return self._fetch_sample_data_from_user_query()
         return self._fetch_sample_data(columns)
 
-    def _fetch_sample_data(self, columns: List[SQALikeColumn]):
+    def _fetch_sample_data(self, columns: List[SQALikeColumn]) -> TableData:
         """
         returns sampled ometa dataframes
         """
         limit = self._get_limit()
         records = self.client.scan(self.table, self.table.columns, limit)
         rows, cols = self.transpose_records(records, columns)
-        return TableData(rows=rows, columns=[col.name for col in cols])
+        return TableData(
+            rows=[list(map(str, row)) for row in rows],
+            columns=[col.name for col in cols],
+        )
 
     def _get_limit(self) -> Optional[int]:
         num_rows = self.client.item_count(self.table)

metadata/profiler/processor/sampler/sampler_factory.py

@@ -15,6 +15,9 @@ Factory class for creating sampler objects
 
 from typing import Union
 
+from metadata.generated.schema.entity.services.connections.database.azureSQLConnection import (
+    AzureSQLConnection,
+)
 from metadata.generated.schema.entity.services.connections.database.bigQueryConnection import (
     BigQueryConnection,
 )
@@ -27,16 +30,25 @@ from metadata.generated.schema.entity.services.connections.database.dynamoDBConn
 from metadata.generated.schema.entity.services.connections.database.mongoDBConnection import (
     MongoDBConnection,
 )
+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.databaseService import DatabaseConnection
 from metadata.profiler.processor.sampler.nosql.sampler import NoSQLSampler
 from metadata.profiler.processor.sampler.pandas.sampler import DatalakeSampler
+from metadata.profiler.processor.sampler.sqlalchemy.azuresql.sampler import (
+    AzureSQLSampler,
+)
 from metadata.profiler.processor.sampler.sqlalchemy.bigquery.sampler import (
     BigQuerySampler,
 )
 from metadata.profiler.processor.sampler.sqlalchemy.sampler import SQASampler
+from metadata.profiler.processor.sampler.sqlalchemy.snowflake.sampler import (
+    SnowflakeSampler,
+)
 from metadata.profiler.processor.sampler.sqlalchemy.trino.sampler import TrinoSampler
 
 
@@ -62,9 +74,27 @@ class SamplerFactory:
 
 
 sampler_factory_ = SamplerFactory()
-sampler_factory_.register(DatabaseConnection.__name__, SQASampler)
-sampler_factory_.register(BigQueryConnection.__name__, BigQuerySampler)
-sampler_factory_.register(DatalakeConnection.__name__, DatalakeSampler)
-sampler_factory_.register(TrinoConnection.__name__, TrinoSampler)
-sampler_factory_.register(MongoDBConnection.__name__, NoSQLSampler)
-sampler_factory_.register(DynamoDBConnection.__name__, NoSQLSampler)
+sampler_factory_.register(
+    source_type=DatabaseConnection.__name__, sampler_class=SQASampler
+)
+sampler_factory_.register(
+    source_type=BigQueryConnection.__name__, sampler_class=BigQuerySampler
+)
+sampler_factory_.register(
+    source_type=DatalakeConnection.__name__, sampler_class=DatalakeSampler
+)
+sampler_factory_.register(
+    source_type=TrinoConnection.__name__, sampler_class=TrinoSampler
+)
+sampler_factory_.register(
+    source_type=MongoDBConnection.__name__, sampler_class=NoSQLSampler
+)
+sampler_factory_.register(
+    source_type=SnowflakeConnection.__name__, sampler_class=SnowflakeSampler
+)
+sampler_factory_.register(
+    source_type=DynamoDBConnection.__name__, sampler_class=NoSQLSampler
+)
+sampler_factory_.register(
+    source_type=AzureSQLConnection.__name__, sampler_class=AzureSQLSampler
+)

metadata/profiler/processor/sampler/sqlalchemy/azuresql/sampler.py

@@ -0,0 +1,40 @@
+#  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.
+"""
+Helper module to handle data sampling
+for the profiler
+"""
+from typing import List, Optional
+
+from sqlalchemy import Column
+
+from metadata.generated.schema.entity.data.table import TableData
+from metadata.profiler.processor.sampler.sqlalchemy.sampler import SQASampler
+
+
+class AzureSQLSampler(SQASampler):
+    """
+    Generates a sample of the data to not
+    run the query in the whole table.
+    """
+
+    # These types are not supported by pyodbc - it throws
+    # an error when trying to fetch data from these columns
+    # pyodbc.ProgrammingError: ('ODBC SQL type -151 is not yet supported.  column-index=x  type=-151', 'HY106')
+    NOT_COMPUTE_PYODBC = {"SQASGeography", "UndeterminedType"}
+
+    def fetch_sample_data(self, columns: Optional[List[Column]] = None) -> TableData:
+        sqa_columns = []
+        if columns:
+            for col in columns:
+                if col.type.__class__.__name__ not in self.NOT_COMPUTE_PYODBC:
+                    sqa_columns.append(col)
+        return super().fetch_sample_data(sqa_columns or columns)

metadata/profiler/processor/sampler/sqlalchemy/sampler.py

@@ -28,7 +28,6 @@ from metadata.generated.schema.entity.data.table import (
 )
 from metadata.profiler.orm.functions.modulo import ModuloFn
 from metadata.profiler.orm.functions.random_num import RandomNumFn
-from metadata.profiler.orm.registry import Dialects
 from metadata.profiler.processor.handle_partition import partition_filter_handler
 from metadata.profiler.processor.sampler.sampler_interface import SamplerInterface
 from metadata.utils.helpers import is_safe_sql_query
@@ -87,17 +86,10 @@ class SQASampler(SamplerInterface):
     def get_sample_query(self, *, column=None) -> Query:
         """get query for sample data"""
         if self.profile_sample_type == ProfileSampleType.PERCENTAGE:
-            rnd = (
-                self._base_sample_query(
-                    column,
-                    (ModuloFn(RandomNumFn(), 100)).label(RANDOM_LABEL),
-                )
-                .suffix_with(
-                    f"SAMPLE BERNOULLI ({self.profile_sample or 100})",
-                    dialect=Dialects.Snowflake,
-                )
-                .cte(f"{self.table.__tablename__}_rnd")
-            )
+            rnd = self._base_sample_query(
+                column,
+                (ModuloFn(RandomNumFn(), 100)).label(RANDOM_LABEL),
+            ).cte(f"{self.table.__tablename__}_rnd")
             session_query = self.client.query(rnd)
             return session_query.where(rnd.c.random <= self.profile_sample).cte(
                 f"{self.table.__tablename__}_sample"
@@ -212,6 +204,10 @@ class SQASampler(SamplerInterface):
 
     def _partitioned_table(self) -> Query:
         """Return the Query object for partitioned tables"""
+        return aliased(self.get_partitioned_query().subquery())
+
+    def get_partitioned_query(self) -> Query:
+        """Return the partitioned query"""
         self._partition_details = cast(
             PartitionProfilerConfig, self._partition_details
         )  # satisfying type checker
@@ -226,61 +222,36 @@ class SQASampler(SamplerInterface):
             self._partition_details.partitionIntervalType
             == PartitionIntervalTypes.COLUMN_VALUE
         ):
-            return aliased(
-                self.table,
-                (
-                    self.client.query(self.table)
-                    .filter(
-                        get_value_filter(
-                            Column(partition_field),
-                            self._partition_details.partitionValues,
-                        )
-                    )
-                    .subquery()
-                ),
+            return self.client.query(self.table).filter(
+                get_value_filter(
+                    Column(partition_field),
+                    self._partition_details.partitionValues,
+                )
             )
-
         if (
             self._partition_details.partitionIntervalType
             == PartitionIntervalTypes.INTEGER_RANGE
         ):
-            return aliased(
-                self.table,
-                (
-                    self.client.query(self.table)
-                    .filter(
-                        get_integer_range_filter(
-                            Column(partition_field),
-                            self._partition_details.partitionIntegerRangeStart,
-                            self._partition_details.partitionIntegerRangeEnd,
-                        )
-                    )
-                    .subquery()
-                ),
+            return self.client.query(self.table).filter(
+                get_integer_range_filter(
+                    Column(partition_field),
+                    self._partition_details.partitionIntegerRangeStart,
+                    self._partition_details.partitionIntegerRangeEnd,
+                )
             )
-
-        return aliased(
-            self.table,
-            (
-                self.client.query(self.table)
-                .filter(
-                    build_query_filter(
-                        [
-                            (
-                                Column(partition_field),
-                                "ge",
-                                dispatch_to_date_or_datetime(
-                                    self._partition_details.partitionInterval,
-                                    text(
-                                        self._partition_details.partitionIntervalUnit.value
-                                    ),
-                                    type_,
-                                ),
-                            )
-                        ],
-                        False,
+        return self.client.query(self.table).filter(
+            build_query_filter(
+                [
+                    (
+                        Column(partition_field),
+                        "ge",
+                        dispatch_to_date_or_datetime(
+                            self._partition_details.partitionInterval,
+                            text(self._partition_details.partitionIntervalUnit.value),
+                            type_,
+                        ),
                     )
-                )
-                .subquery()
-            ),
+                ],
+                False,
+            )
         )

metadata/profiler/processor/sampler/sqlalchemy/snowflake/sampler.py

@@ -0,0 +1,60 @@
+#  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.
+"""
+Helper module to handle data sampling
+for the profiler
+"""
+
+from typing import cast
+
+from sqlalchemy import Table
+from sqlalchemy.sql.selectable import CTE
+
+from metadata.generated.schema.entity.data.table import ProfileSampleType
+from metadata.profiler.processor.handle_partition import partition_filter_handler
+from metadata.profiler.processor.sampler.sqlalchemy.sampler import SQASampler
+
+
+class SnowflakeSampler(SQASampler):
+    """
+    Generates a sample of the data to not
+    run the query in the whole table.
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+    @partition_filter_handler(build_sample=True)
+    def get_sample_query(self, *, column=None) -> CTE:
+        """get query for sample data"""
+        # TABLESAMPLE SYSTEM is not supported for views
+        self.table = cast(Table, self.table)
+
+        if self.profile_sample_type == ProfileSampleType.PERCENTAGE:
+            rnd = (
+                self._base_sample_query(
+                    column,
+                )
+                .suffix_with(
+                    f"SAMPLE BERNOULLI ({self.profile_sample or 100})",
+                )
+                .cte(f"{self.table.__tablename__}_rnd")
+            )
+            session_query = self.client.query(rnd)
+            return session_query.cte(f"{self.table.__tablename__}_sample")
+
+        return (
+            self._base_sample_query(column)
+            .suffix_with(
+                f"TABLESAMPLE ({self.profile_sample or 100} ROWS)",
+            )
+            .cte(f"{self.table.__tablename__}_sample")
+        )

metadata/profiler/source/base/profiler_source.py

@@ -65,8 +65,8 @@ class ProfilerSource(ProfilerSourceInterface):
         self.source_config = cast(
             DatabaseServiceProfilerPipeline, self.source_config
         )  # satisfy type checker
-        self.profiler_config = ProfilerProcessorConfig.parse_obj(
-            config.processor.dict().get("config")
+        self.profiler_config = ProfilerProcessorConfig.model_validate(
+            config.processor.model_dump().get("config")
         )
         self.ometa_client = ometa_client
         self.profiler_interface_type: str = self._get_profiler_interface_type(config)
@@ -102,7 +102,7 @@ class ProfilerSource(ProfilerSourceInterface):
         """
         if isinstance(self.service_conn_config, NON_SQA_DATABASE_CONNECTIONS):
             return self.service_conn_config.__class__.__name__
-        return config.source.serviceConnection.__root__.config.__class__.__name__
+        return config.source.serviceConnection.root.config.__class__.__name__
 
     @staticmethod
     def get_config_for_table(entity: Table, profiler_config) -> Optional[TableConfig]:
@@ -112,27 +112,24 @@ class ProfilerSource(ProfilerSourceInterface):
             entity: table entity
         """
         for table_config in profiler_config.tableConfig or []:
-            if (
-                table_config.fullyQualifiedName.__root__
-                == entity.fullyQualifiedName.__root__
-            ):
+            if table_config.fullyQualifiedName.root == entity.fullyQualifiedName.root:
                 return table_config
 
         for schema_config in profiler_config.schemaConfig or []:
             if (
-                schema_config.fullyQualifiedName.__root__
+                schema_config.fullyQualifiedName.root
                 == entity.databaseSchema.fullyQualifiedName
             ):
                 return TableConfig.from_database_and_schema_config(
-                    schema_config, entity.fullyQualifiedName.__root__
+                    schema_config, entity.fullyQualifiedName.root
                 )
         for database_config in profiler_config.databaseConfig or []:
             if (
-                database_config.fullyQualifiedName.__root__
+                database_config.fullyQualifiedName.root
                 == entity.database.fullyQualifiedName
             ):
                 return TableConfig.from_database_and_schema_config(
-                    database_config, entity.fullyQualifiedName.__root__
+                    database_config, entity.fullyQualifiedName.root
                 )
 
         return None
@@ -173,16 +170,16 @@ class ProfilerSource(ProfilerSourceInterface):
             DatabaseService.__config__
         """
         config_copy = deepcopy(
-            config.source.serviceConnection.__root__.config  # type: ignore
+            config.source.serviceConnection.root.config  # type: ignore
         )
         if hasattr(
             config_copy,  # type: ignore
             "supportsDatabase",
         ):
             if hasattr(config_copy, "database"):
-                config_copy.database = database.name.__root__  # type: ignore
+                config_copy.database = database.name.root  # type: ignore
             if hasattr(config_copy, "catalog"):
-                config_copy.catalog = database.name.__root__  # type: ignore
+                config_copy.catalog = database.name.root  # type: ignore
 
         # we know we'll only be working with DatabaseConnection, we cast the type to satisfy type checker
         config_copy = cast(DatabaseConnection, config_copy)
@@ -280,6 +277,7 @@ class ProfilerSource(ProfilerSourceInterface):
                 include_columns=self._get_include_columns(entity, table_config),
                 exclude_columns=self._get_exclude_columns(entity, table_config),
                 global_profiler_configuration=self.global_profiler_configuration,
+                db_service=db_service,
             )
 
         metrics = (

metadata/profiler/source/bigquery/profiler_source.py

@@ -47,7 +47,7 @@ class BigQueryProfilerSource(ProfilerSource):
             DatabaseConnection
         """
         config_copy: BigQueryConnection = deepcopy(
-            config.source.serviceConnection.__root__.config  # type: ignore
+            config.source.serviceConnection.root.config  # type: ignore
         )
 
         if isinstance(config_copy.credentials.gcpConfig, GcpCredentialsValues):
@@ -55,7 +55,7 @@ class BigQueryProfilerSource(ProfilerSource):
                 config_copy.credentials.gcpConfig.projectId, MultipleProjectId
             ):
                 config_copy.credentials.gcpConfig.projectId = SingleProjectId(
-                    __root__=database.name.__root__
+                    database.name.root
                 )
 
         return config_copy

metadata/profiler/source/bigquery/type_mapper.py

@@ -36,10 +36,10 @@ def bigquery_type_mapper(_type_map: dict, col: Column):
                     type_ = _type_map.get(child.dataType)(item_type=child.arrayDataType)
                 else:
                     type_ = _type_map.get(child.dataType)
-                structs.append((child.name.__root__, type_))
+                structs.append((child.name.root, type_))
             else:
                 nested_structs = build_struct(_type_map, child)
-                structs.append((child.name.__root__, STRUCT(*nested_structs)))
+                structs.append((child.name.root, STRUCT(*nested_structs)))
         return structs
 
     return STRUCT(*build_struct(_type_map, col))