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

metadata/parsers/avro_parser.py

@@ -14,11 +14,11 @@ Utils module to parse the avro schema
 """
 
 import traceback
-from typing import List, Optional, Tuple, Union
+from typing import List, Optional, Tuple, Type, Union
 
 import avro.schema as avroschema
 from avro.schema import ArraySchema, RecordSchema, Schema, UnionSchema
-from pydantic.main import ModelMetaclass
+from pydantic import BaseModel
 
 from metadata.generated.schema.entity.data.table import Column
 from metadata.generated.schema.type.schema import FieldModel
@@ -30,7 +30,7 @@ RECORD_DATATYPE_NAME = "RECORD"
 
 
 def _parse_array_children(
-    arr_item: Schema, cls: ModelMetaclass = FieldModel
+    arr_item: Schema, cls: Type[BaseModel] = FieldModel
 ) -> Tuple[str, Optional[Union[FieldModel, Column]]]:
     if isinstance(arr_item, ArraySchema):
         display_type, children = _parse_array_children(arr_item.items, cls=cls)
@@ -55,7 +55,7 @@ def _parse_array_children(
 
 
 def parse_array_fields(
-    field: ArraySchema, cls: ModelMetaclass = FieldModel
+    field: ArraySchema, cls: Type[BaseModel] = FieldModel
 ) -> Optional[List[Union[FieldModel, Column]]]:
     """
     Parse array field for avro schema
@@ -106,7 +106,9 @@ def parse_array_fields(
 
 
 def _parse_union_children(
-    parent: Optional[Schema], union_field: UnionSchema, cls: ModelMetaclass = FieldModel
+    parent: Optional[Schema],
+    union_field: UnionSchema,
+    cls: Type[BaseModel] = FieldModel,
 ) -> Tuple[str, Optional[Union[FieldModel, Column]]]:
     non_null_schema = [
         (i, schema)
@@ -137,7 +139,7 @@ def _parse_union_children(
     return sub_type, None
 
 
-def parse_record_fields(field: RecordSchema, cls: ModelMetaclass = FieldModel):
+def parse_record_fields(field: RecordSchema, cls: Type[BaseModel] = FieldModel):
     """
     Parse the nested record fields for avro
     """
@@ -160,7 +162,7 @@ def parse_record_fields(field: RecordSchema, cls: ModelMetaclass = FieldModel):
 def parse_union_fields(
     parent: Optional[Schema],
     union_field: Schema,
-    cls: ModelMetaclass = FieldModel,
+    cls: Type[BaseModel] = FieldModel,
 ) -> Optional[List[Union[FieldModel, Column]]]:
     """
     Parse union field for avro schema
@@ -209,7 +211,7 @@ def parse_union_fields(
 
 
 def parse_single_field(
-    field: Schema, cls: ModelMetaclass = FieldModel
+    field: Schema, cls: Type[BaseModel] = FieldModel
 ) -> Optional[List[Union[FieldModel, Column]]]:
     """
     Parse primitive field for avro schema
@@ -224,7 +226,7 @@ def parse_single_field(
 
 
 def parse_avro_schema(
-    schema: str, cls: ModelMetaclass = FieldModel
+    schema: str, cls: Type[BaseModel] = FieldModel
 ) -> Optional[List[Union[FieldModel, Column]]]:
     """
     Method to parse the avro schema
@@ -247,7 +249,7 @@ def parse_avro_schema(
 
 
 def get_avro_fields(
-    parsed_schema: Schema, cls: ModelMetaclass = FieldModel
+    parsed_schema: Schema, cls: Type[BaseModel] = FieldModel
 ) -> Optional[List[Union[FieldModel, Column]]]:
     """
     Recursively convert the parsed schema into required models

metadata/parsers/json_schema_parser.py

@@ -16,9 +16,9 @@ Utils module to parse the jsonschema
 import json
 import traceback
 from enum import Enum
-from typing import List, Optional
+from typing import List, Optional, Type
 
-from pydantic.main import ModelMetaclass
+from pydantic import BaseModel
 
 from metadata.generated.schema.type.schema import FieldModel
 from metadata.utils.logger import ingestion_logger
@@ -42,7 +42,7 @@ class JsonSchemaDataTypes(Enum):
 
 
 def parse_json_schema(
-    schema_text: str, cls: ModelMetaclass = FieldModel
+    schema_text: str, cls: Type[BaseModel] = FieldModel
 ) -> Optional[List[FieldModel]]:
     """
     Method to parse the jsonschema
@@ -67,7 +67,7 @@ def parse_json_schema(
 
 
 def get_json_schema_fields(
-    properties, cls: ModelMetaclass = FieldModel
+    properties, cls: Type[BaseModel] = FieldModel
 ) -> Optional[List[FieldModel]]:
     """
     Recursively convert the parsed schema into required models

metadata/parsers/protobuf_parser.py

@@ -20,11 +20,10 @@ import sys
 import traceback
 from enum import Enum
 from pathlib import Path
-from typing import List, Optional, Union
+from typing import List, Optional, Type, Union
 
 import grpc_tools.protoc
 from pydantic import BaseModel
-from pydantic.main import ModelMetaclass
 
 from metadata.generated.schema.entity.data.table import Column, DataType
 from metadata.generated.schema.type.schema import DataTypeTopic, FieldModel
@@ -168,7 +167,7 @@ class ProtobufParser:
         return None
 
     def parse_protobuf_schema(
-        self, cls: ModelMetaclass = FieldModel
+        self, cls: Type[BaseModel] = FieldModel
     ) -> Optional[List[Union[FieldModel, Column]]]:
         """
         Method to parse the protobuf schema
@@ -202,7 +201,7 @@ class ProtobufParser:
             )
         return None
 
-    def _get_field_type(self, type_: int, cls: ModelMetaclass = FieldModel) -> str:
+    def _get_field_type(self, type_: int, cls: Type[BaseModel] = FieldModel) -> str:
         if type_ > 18:
             return DataType.UNKNOWN.value
         data_type = ProtobufDataTypes(type_).name
@@ -211,7 +210,7 @@ class ProtobufParser:
         return data_type
 
     def get_protobuf_fields(
-        self, fields, cls: ModelMetaclass = FieldModel
+        self, fields, cls: Type[BaseModel] = FieldModel
     ) -> Optional[List[Union[FieldModel, Column]]]:
         """
         Recursively convert the parsed schema into required models

metadata/pii/processor.py

@@ -120,9 +120,7 @@ class PIIProcessor(Processor):
 
         # First, check if the column we are about to process
         # already has PII tags or not
-        column_has_pii_tag = any(
-            (PII in tag.tagFQN.__root__ for tag in column.tags or [])
-        )
+        column_has_pii_tag = any((PII in tag.tagFQN.root for tag in column.tags or []))
 
         # If it has PII tags, we skip the processing
         # for the column
@@ -130,7 +128,7 @@ class PIIProcessor(Processor):
             return None
 
         # Scan by column name. If no results there, check the sample data, if any
-        tag_and_confidence = ColumnNameScanner.scan(column.name.__root__) or (
+        tag_and_confidence = ColumnNameScanner.scan(column.name.root) or (
             self.ner_scanner.scan([row[idx] for row in table_data.rows])
             if table_data
             else None
@@ -145,7 +143,7 @@ class PIIProcessor(Processor):
             return [
                 self.build_column_tag(
                     tag_fqn=tag_and_confidence.tag_fqn,
-                    column_fqn=column.fullyQualifiedName.__root__,
+                    column_fqn=column.fullyQualifiedName.root,
                 )
             ]
 
@@ -180,7 +178,7 @@ class PIIProcessor(Processor):
             except Exception as err:
                 self.status.failed(
                     StackTraceError(
-                        name=record.table.fullyQualifiedName.__root__,
+                        name=record.table.fullyQualifiedName.root,
                         error=f"Error computing PII tags for [{column}] - [{err}]",
                         stackTrace=traceback.format_exc(),
                     )

metadata/profiler/adaptors/dynamodb.py

@@ -29,12 +29,12 @@ class DynamoDB(NoSQLAdaptor):
         self.client = client
 
     def item_count(self, table: Table) -> int:
-        table = self.client.Table(table.name.__root__)
+        table = self.client.Table(table.name.root)
         return table.item_count
 
     def scan(
         self, table: Table, columns: List[Column], limit: int
     ) -> List[Dict[str, any]]:
-        table = self.client.Table(table.name.__root__)
+        table = self.client.Table(table.name.root)
         response = table.scan(Limit=limit)
         return response["Items"]

metadata/profiler/adaptors/mongodb.py

@@ -92,7 +92,7 @@ class MongoDB(NoSQLAdaptor):
 
     def item_count(self, table: Table) -> int:
         db = self.client[table.databaseSchema.name]
-        collection = db[table.name.__root__]
+        collection = db[table.name.root]
         return collection.count_documents({})
 
     def scan(
@@ -101,7 +101,7 @@ class MongoDB(NoSQLAdaptor):
         return self.execute(
             Query(
                 database=table.databaseSchema.name,
-                collection=table.name.__root__,
+                collection=table.name.root,
                 limit=limit,
             )
         )
@@ -116,7 +116,7 @@ class MongoDB(NoSQLAdaptor):
         return self.execute(
             Query(
                 database=table.databaseSchema.name,
-                collection=table.name.__root__,
+                collection=table.name.root,
                 filter=json_query,
             )
         )
@@ -143,7 +143,7 @@ class MongoDB(NoSQLAdaptor):
         row = self.execute(
             Aggregation(
                 database=table.databaseSchema.name,
-                collection=table.name.__root__,
+                collection=table.name.root,
                 column=column.name,
                 aggregations=aggregate_functions,
             )
@@ -163,16 +163,4 @@ class MongoDB(NoSQLAdaptor):
         return AggregationFunction.MIN
 
     def execute(self, query: Executable) -> List[Dict[str, any]]:
-        records = list(query.to_executable(self.client))
-        result = []
-        for r in records:
-            result.append({c: self._json_safe(r.get(c)) for c in r})
-        return result
-
-    @staticmethod
-    def _json_safe(data: any):
-        try:
-            json.dumps(data)
-            return data
-        except Exception:  # noqa
-            return str(data)
+        return list(query.to_executable(self.client))

metadata/profiler/api/models.py

@@ -17,6 +17,7 @@ multiple profilers per table and columns.
 """
 from typing import List, Optional, Type, Union
 
+from pydantic import ConfigDict
 from sqlalchemy import Column
 from sqlalchemy.orm import DeclarativeMeta
 
@@ -45,8 +46,8 @@ from metadata.utils.sqa_like_column import SQALikeColumn
 class ColumnConfig(ConfigModel):
     """Column config for profiler"""
 
-    excludeColumns: Optional[List[str]]
-    includeColumns: Optional[List[ColumnProfilerConfig]]
+    excludeColumns: Optional[List[str]] = None
+    includeColumns: Optional[List[ColumnProfilerConfig]] = None
 
 
 class BaseProfileConfig(ConfigModel):
@@ -62,8 +63,8 @@ class TableConfig(BaseProfileConfig):
     """table profile config"""
 
     profileQuery: Optional[str] = None
-    partitionConfig: Optional[PartitionProfilerConfig]
-    columnConfig: Optional[ColumnConfig]
+    partitionConfig: Optional[PartitionProfilerConfig] = None
+    columnConfig: Optional[ColumnConfig] = None
 
     @classmethod
     def from_database_and_schema_config(
@@ -118,16 +119,15 @@ class ProfilerResponse(ConfigModel):
 
     def __str__(self):
         """Return the table name being processed"""
-        return f"Table [{self.table.name.__root__}]"
+        return f"Table [{self.table.name.root}]"
 
 
 class ThreadPoolMetrics(ConfigModel):
     """A container for all metrics to be computed on the same thread."""
 
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
     metrics: Union[List[Union[Type[Metric], CustomMetric]], Type[Metric]]
     metric_type: MetricTypes
-    column: Optional[Union[Column, SQALikeColumn]]
+    column: Optional[Union[Column, SQALikeColumn]] = None
     table: Union[Table, DeclarativeMeta]
-
-    class Config:
-        arbitrary_types_allowed = True

metadata/profiler/interface/nosql/profiler_interface.py

@@ -16,7 +16,7 @@ supporting sqlalchemy abstraction layer
 """
 import traceback
 from collections import defaultdict
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import Dict, List, Optional, Type
 
 from sqlalchemy import Column
@@ -148,9 +148,9 @@ class NoSQLProfilerInterface(ProfilerInterface):
             row = None
         if metric_func.column is not None:
             column = metric_func.column.name
-            self.status.scanned(f"{metric_func.table.name.__root__}.{column}")
+            self.status.scanned(f"{metric_func.table.name.root}.{column}")
         else:
-            self.status.scanned(metric_func.table.name.__root__)
+            self.status.scanned(metric_func.table.name.root)
             column = None
         return row, column, metric_func.metric_type.value
 
@@ -212,9 +212,7 @@ class NoSQLProfilerInterface(ProfilerInterface):
                     profile_results["columns"][column].update(
                         {
                             "name": column,
-                            "timestamp": int(
-                                datetime.now(tz=timezone.utc).timestamp() * 1000
-                            ),
+                            "timestamp": int(datetime.now().timestamp() * 1000),
                             **profile,
                         }
                     )
@@ -227,8 +225,7 @@ class NoSQLProfilerInterface(ProfilerInterface):
 
     def get_columns(self) -> List[Optional[SQALikeColumn]]:
         return [
-            SQALikeColumn(name=c.name.__root__, type=c.dataType)
-            for c in self.table.columns
+            SQALikeColumn(name=c.name.root, type=c.dataType) for c in self.table.columns
         ]
 
     def close(self):

metadata/profiler/interface/pandas/profiler_interface.py

@@ -17,7 +17,7 @@ supporting sqlalchemy abstraction layer
 import traceback
 from collections import defaultdict
 from copy import deepcopy
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import Dict, List, Optional
 
 from sqlalchemy import Column
@@ -88,7 +88,7 @@ class PandasProfilerInterface(ProfilerInterface, PandasInterfaceMixin):
         self.client = self.connection.client
         self.dfs = self.return_ometa_dataframes_sampled(
             service_connection_config=self.service_connection_config,
-            client=self.client,
+            client=self.client._client,
             table=self.table_entity,
             profile_sample_config=profile_sample_config,
         )
@@ -137,7 +137,7 @@ class PandasProfilerInterface(ProfilerInterface, PandasInterfaceMixin):
 
         return sampler_factory_.create(
             DatalakeConnection.__name__,
-            client=self.client,
+            client=self.client._client,  # pylint: disable=W0212
             table=self.dfs,
             profile_sample_config=self.profile_sample_config,
             partition_details=self.partition_details,
@@ -287,7 +287,7 @@ class PandasProfilerInterface(ProfilerInterface, PandasInterfaceMixin):
                     if len(df.query(metric.expression).index)
                 )
                 custom_metrics.append(
-                    CustomMetricProfile(name=metric.name.__root__, value=row)
+                    CustomMetricProfile(name=metric.name.root, value=row)
                 )
 
             except Exception as exc:
@@ -303,7 +303,7 @@ class PandasProfilerInterface(ProfilerInterface, PandasInterfaceMixin):
         metric_func: ThreadPoolMetrics,
     ):
         """Run metrics in processor worker"""
-        logger.debug(f"Running profiler for {metric_func.table.name.__root__}")
+        logger.debug(f"Running profiler for {metric_func.table.name.root}")
         try:
             row = None
             if self.complex_dataframe_sample:
@@ -320,9 +320,9 @@ class PandasProfilerInterface(ProfilerInterface, PandasInterfaceMixin):
             row = None
         if metric_func.column is not None:
             column = metric_func.column.name
-            self.status.scanned(f"{metric_func.table.name.__root__}.{column}")
+            self.status.scanned(f"{metric_func.table.name.root}.{column}")
         else:
-            self.status.scanned(metric_func.table.name.__root__)
+            self.status.scanned(metric_func.table.name.root)
             column = None
         return row, column, metric_func.metric_type.value
 
@@ -403,9 +403,7 @@ class PandasProfilerInterface(ProfilerInterface, PandasInterfaceMixin):
                         profile_results["columns"][column].update(
                             {
                                 "name": column,
-                                "timestamp": int(
-                                    datetime.now(tz=timezone.utc).timestamp() * 1000
-                                ),
+                                "timestamp": int(datetime.now().timestamp() * 1000),
                                 **profile,
                             }
                         )

metadata/profiler/interface/profiler_interface.py

@@ -117,7 +117,7 @@ class ProfilerInterface(ABC):
         except AttributeError:
             self.status.entity = None
         else:
-            self.status.entity = fqn.__root__ if fqn else None
+            self.status.entity = fqn.root if fqn else None
         self.profile_sample_config = profile_sample_config
         self.profile_query = sample_query
         self.partition_details = (
@@ -272,7 +272,7 @@ class ProfilerInterface(ABC):
         """
         for schema_config in profiler_config.schemaConfig:
             if (
-                schema_config.fullyQualifiedName.__root__
+                schema_config.fullyQualifiedName.root
                 == entity.databaseSchema.fullyQualifiedName
                 and ProfilerInterface._get_sample_storage_config(schema_config)
             ):
@@ -280,7 +280,7 @@ class ProfilerInterface(ABC):
 
         for database_config in profiler_config.databaseConfig:
             if (
-                database_config.fullyQualifiedName.__root__
+                database_config.fullyQualifiedName.root
                 == entity.database.fullyQualifiedName
                 and ProfilerInterface._get_sample_storage_config(database_config)
             ):

metadata/profiler/interface/profiler_interface_factory.py

@@ -13,7 +13,8 @@
 Factory class for creating profiler interface objects
 """
 
-from typing import cast
+import importlib
+from typing import Dict, cast
 
 from metadata.generated.schema.entity.services.connections.database.bigQueryConnection import (
     BigQueryConnection,
@@ -50,63 +51,57 @@ from metadata.generated.schema.entity.services.connections.database.unityCatalog
 )
 from metadata.generated.schema.entity.services.databaseService import DatabaseConnection
 from metadata.profiler.factory import Factory
-from metadata.profiler.interface.nosql.profiler_interface import NoSQLProfilerInterface
-from metadata.profiler.interface.pandas.profiler_interface import (
-    PandasProfilerInterface,
-)
 from metadata.profiler.interface.profiler_interface import ProfilerInterface
-from metadata.profiler.interface.sqlalchemy.bigquery.profiler_interface import (
-    BigQueryProfilerInterface,
-)
-from metadata.profiler.interface.sqlalchemy.databricks.profiler_interface import (
-    DatabricksProfilerInterface,
-)
-from metadata.profiler.interface.sqlalchemy.db2.profiler_interface import (
-    DB2ProfilerInterface,
-)
-from metadata.profiler.interface.sqlalchemy.mariadb.profiler_interface import (
-    MariaDBProfilerInterface,
-)
-from metadata.profiler.interface.sqlalchemy.profiler_interface import (
-    SQAProfilerInterface,
-)
-from metadata.profiler.interface.sqlalchemy.single_store.profiler_interface import (
-    SingleStoreProfilerInterface,
-)
-from metadata.profiler.interface.sqlalchemy.snowflake.profiler_interface import (
-    SnowflakeProfilerInterface,
-)
-from metadata.profiler.interface.sqlalchemy.trino.profiler_interface import (
-    TrinoProfilerInterface,
-)
-from metadata.profiler.interface.sqlalchemy.unity_catalog.profiler_interface import (
-    UnityCatalogProfilerInterface,
-)
 
 
 class ProfilerInterfaceFactory(Factory):
     def create(self, interface_type: str, *args, **kwargs):
         """Create interface object based on interface type"""
-        interface_class = self._interface_type.get(interface_type)
-        if not interface_class:
-            interface_class = self._interface_type.get(DatabaseConnection.__name__)
-        interface_class = cast(ProfilerInterface, interface_class)
-        return interface_class.create(*args, **kwargs)
+        interface_class_path = profiler_class_mapping.get(
+            interface_type, profiler_class_mapping[DatabaseConnection.__name__]
+        )
+        try:
+            module_path, class_name = interface_class_path.rsplit(".", 1)
+            module = importlib.import_module(module_path)
+            profiler_class = getattr(module, class_name)
+        except (ImportError, AttributeError) as e:
+            raise ImportError(f"Error importing {class_name} from {module_path}: {e}")
+        profiler_class = cast(ProfilerInterface, profiler_class)
+        return profiler_class.create(*args, **kwargs)
 
 
 profiler_interface_factory = ProfilerInterfaceFactory()
-profilers = {
-    DatabaseConnection.__name__: SQAProfilerInterface,
-    BigQueryConnection.__name__: BigQueryProfilerInterface,
-    SingleStoreConnection.__name__: SingleStoreProfilerInterface,
-    DatalakeConnection.__name__: PandasProfilerInterface,
-    MariaDBConnection.__name__: MariaDBProfilerInterface,
-    SnowflakeConnection.__name__: SnowflakeProfilerInterface,
-    TrinoConnection.__name__: TrinoProfilerInterface,
-    UnityCatalogConnection.__name__: UnityCatalogProfilerInterface,
-    DatabricksConnection.__name__: DatabricksProfilerInterface,
-    Db2Connection.__name__: DB2ProfilerInterface,
-    MongoDBConnection.__name__: NoSQLProfilerInterface,
-    DynamoDBConnection.__name__: NoSQLProfilerInterface,
+
+BASE_PROFILER_PATH = "metadata.profiler.interface"
+SQLALCHEMY_PROFILER_PATH = f"{BASE_PROFILER_PATH}.sqlalchemy"
+NOSQL_PROFILER_PATH = (
+    f"{BASE_PROFILER_PATH}.nosql.profiler_interface.NoSQLProfilerInterface"
+)
+PANDAS_PROFILER_PATH = (
+    f"{BASE_PROFILER_PATH}.pandas.profiler_interface.PandasProfilerInterface"
+)
+
+# Configuration for dynamic imports
+profiler_class_mapping: Dict[str, str] = {
+    DatabaseConnection.__name__: SQLALCHEMY_PROFILER_PATH
+    + ".profiler_interface.SQAProfilerInterface",
+    BigQueryConnection.__name__: SQLALCHEMY_PROFILER_PATH
+    + ".bigquery.profiler_interface.BigQueryProfilerInterface",
+    SingleStoreConnection.__name__: SQLALCHEMY_PROFILER_PATH
+    + ".single_store.profiler_interface.SingleStoreProfilerInterface",
+    DatalakeConnection.__name__: PANDAS_PROFILER_PATH,
+    MariaDBConnection.__name__: SQLALCHEMY_PROFILER_PATH
+    + ".mariadb.profiler_interface.MariaDBProfilerInterface",
+    SnowflakeConnection.__name__: SQLALCHEMY_PROFILER_PATH
+    + ".snowflake.profiler_interface.SnowflakeProfilerInterface",
+    TrinoConnection.__name__: SQLALCHEMY_PROFILER_PATH
+    + ".trino.profiler_interface.TrinoProfilerInterface",
+    UnityCatalogConnection.__name__: SQLALCHEMY_PROFILER_PATH
+    + ".unity_catalog.profiler_interface.UnityCatalogProfilerInterface",
+    DatabricksConnection.__name__: SQLALCHEMY_PROFILER_PATH
+    + ".databricks.profiler_interface.DatabricksProfilerInterface",
+    Db2Connection.__name__: SQLALCHEMY_PROFILER_PATH
+    + ".db2.profiler_interface.DB2ProfilerInterface",
+    MongoDBConnection.__name__: NOSQL_PROFILER_PATH,
+    DynamoDBConnection.__name__: NOSQL_PROFILER_PATH,
 }
-profiler_interface_factory.register_many(profilers)

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

@@ -36,15 +36,17 @@ class DatabricksProfilerInterface(SQAProfilerInterface):
         result = super(  # pylint: disable=bad-super-call
             HiveCompiler, self
         ).visit_column(*args, **kwargs)
-        dot_count = result.count(".")
         # Here the databricks uses HiveCompiler.
         # the `result` here would be `db.schema.table` or `db.schema.table.column`
         # for struct it will be `db.schema.table.column.nestedchild.nestedchild` etc
         # the logic is to add the backticks to nested children.
-        if dot_count > 2:
-            splitted_result = result.split(".", 2)[-1].split(".")
-            result = ".".join(result.split(".", 2)[:-1])
-            result += "." + "`.`".join(splitted_result)
+        dot_count = result.count(".")
+        if dot_count > 1 and "." in result.split("`.`")[-1]:
+            splitted_result = result.split("`.")[-1].split(".")
+            result = "`.".join(result.split("`.")[:-1])
+            if result:
+                result += "`."
+            result += "`.`".join(splitted_result)
         return result
 
     def __init__(self, service_connection_config, **kwargs):
@@ -56,31 +58,40 @@ class DatabricksProfilerInterface(SQAProfilerInterface):
         """Get struct columns"""
 
         columns_list = []
-        for idx, col in enumerate(columns):
+        for col in columns:
             if col.dataType != DataType.STRUCT:
-                col.name = ColumnName(__root__=f"{parent}.{col.name.__root__}")
-                col = build_orm_col(idx, col, DatabaseServiceType.Databricks)
-                col._set_parent(  # pylint: disable=protected-access
+                # For DBX struct we need to quote the column name as `a`.`b`.`c`
+                # otherwise the driver will quote it as `a.b.c`
+                col_name = ".".join([f"`{part}`" for part in parent.split(".")])
+                col.name = ColumnName(f"{col_name}.`{col.name.root}`")
+                # Set `_quote` to False to avoid quoting the column name again when compiled
+                sqa_col = build_orm_col(
+                    idx=1,
+                    col=col,
+                    table_service_type=DatabaseServiceType.Databricks,
+                    _quote=False,
+                )
+                sqa_col._set_parent(  # pylint: disable=protected-access
                     self.table.__table__
                 )
-                columns_list.append(col)
+                columns_list.append(sqa_col)
             else:
-                col = self._get_struct_columns(
-                    col.children, f"{parent}.{col.name.__root__}"
+                cols = self._get_struct_columns(
+                    col.children, f"{parent}.{col.name.root}"
                 )
-                columns_list.extend(col)
+                columns_list.extend(cols)
         return columns_list
 
     def get_columns(self) -> Column:
         """Get columns from table"""
         columns = []
-        for idx, column in enumerate(self.table_entity.columns):
-            if column.dataType == DataType.STRUCT:
+        for idx, column_obj in enumerate(self.table_entity.columns):
+            if column_obj.dataType == DataType.STRUCT:
                 columns.extend(
-                    self._get_struct_columns(column.children, column.name.__root__)
+                    self._get_struct_columns(column_obj.children, column_obj.name.root)
                 )
             else:
-                col = build_orm_col(idx, column, DatabaseServiceType.Databricks)
+                col = build_orm_col(idx, column_obj, DatabaseServiceType.Databricks)
                 col._set_parent(  # pylint: disable=protected-access
                     self.table.__table__
                 )