openmetadata-ingestion 1.6.2.2__py3-none-any.whl → 1.6.3.0.dev0__py3-none-any.whl

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

@@ -193,7 +193,7 @@ POSTGRES_SQL_COLUMNS = """
     """
 
 POSTGRES_GET_SERVER_VERSION = """
-show server_version
+show server_version_num
 """
 
 POSTGRES_FETCH_FK = """
@@ -212,91 +212,6 @@ POSTGRES_FETCH_FK = """
     ORDER BY 1
 """
 
-POSTGRES_GET_JSON_FIELDS = """
-    WITH RECURSIVE json_hierarchy AS (
-        SELECT
-            key AS path,
-            json_typeof(value) AS type,
-            value,
-            json_build_object() AS properties,
-            key AS title
-        FROM
-            {table_name} tbd,
-            LATERAL json_each({column_name}::json)
-    ),
-    build_hierarchy AS (
-        SELECT
-            path,
-            type,
-            title,
-            CASE
-                WHEN type = 'object' THEN
-                    json_build_object(
-                        'title', title,
-                        'type', 'object',
-                        'properties', (
-                            SELECT json_object_agg(
-                                key,
-                                json_build_object(
-                                    'title', key,
-                                    'type', json_typeof(value),
-                                    'properties', (
-                                        CASE
-                                            WHEN json_typeof(value) = 'object' THEN
-                                                (
-                                                    SELECT json_object_agg(
-                                                        key,
-                                                        json_build_object(
-                                                            'title', key,
-                                                            'type', json_typeof(value),
-                                                            'properties',
-                                                            json_build_object()
-                                                        )
-                                                    )
-                                                    FROM json_each(value::json) AS sub_key_value
-                                                )
-                                            ELSE json_build_object()
-                                        END
-                                    )
-                                )
-                            )
-                            FROM json_each(value::json) AS key_value
-                        )
-                    )
-                WHEN type = 'array' THEN
-                    json_build_object(
-                        'title', title,
-                        'type', 'array',
-                        'properties', json_build_object()
-                    )
-                ELSE
-                    json_build_object(
-                        'title', title,
-                        'type', type
-                    )
-            END AS hierarchy
-        FROM
-            json_hierarchy
-    ),
-    aggregate_hierarchy AS (
-        select
-            json_build_object(
-            'title','{column_name}',
-            'type','object',
-            'properties',
-            json_object_agg(
-                path,
-                hierarchy
-            )) AS result
-        FROM
-            build_hierarchy
-    )
-    SELECT
-        result
-    FROM
-        aggregate_hierarchy;
-"""
-
 POSTGRES_GET_STORED_PROCEDURES = """
     SELECT proname AS procedure_name,
         nspname AS schema_name,

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

@@ -13,7 +13,6 @@
 """
 Postgres SQLAlchemy util methods
 """
-import json
 import re
 import traceback
 from typing import Dict, Optional, Tuple
@@ -24,18 +23,15 @@ from sqlalchemy.dialects.postgresql.base import ENUM
 from sqlalchemy.engine import reflection
 from sqlalchemy.sql import sqltypes
 
-from metadata.generated.schema.entity.data.table import Column
 from metadata.ingestion.source.database.postgres.queries import (
     POSTGRES_COL_IDENTITY,
     POSTGRES_FETCH_FK,
-    POSTGRES_GET_JSON_FIELDS,
     POSTGRES_GET_SERVER_VERSION,
     POSTGRES_SQL_COLUMNS,
     POSTGRES_TABLE_COMMENTS,
     POSTGRES_TABLE_OWNERS,
     POSTGRES_VIEW_DEFINITIONS,
 )
-from metadata.parsers.json_schema_parser import parse_json_schema
 from metadata.utils.logger import utils_logger
 from metadata.utils.sqlalchemy_utils import (
     get_table_comment_wrapper,
@@ -45,7 +41,7 @@ from metadata.utils.sqlalchemy_utils import (
 
 logger = utils_logger()
 
-OLD_POSTGRES_VERSION = "13.0"
+OLD_POSTGRES_VERSION = "130000"
 
 
 def get_etable_owner(
@@ -190,28 +186,6 @@ def get_table_comment(
     )
 
 
-@reflection.cache
-def get_json_fields_and_type(
-    self, table_name, column_name, schema=None, **kw
-):  # pylint: disable=unused-argument
-    try:
-        query = POSTGRES_GET_JSON_FIELDS.format(
-            table_name=table_name, column_name=column_name
-        )
-        cursor = self.engine.execute(query)
-        result = cursor.fetchone()
-        if result:
-            parsed_column = parse_json_schema(json.dumps(result[0]), Column)
-            if parsed_column:
-                return parsed_column[0].children
-    except Exception as err:
-        logger.warning(
-            f"Unable to parse the json fields for {table_name}.{column_name} - {err}"
-        )
-        logger.debug(traceback.format_exc())
-    return None
-
-
 @reflection.cache
 def get_columns(  # pylint: disable=too-many-locals
     self, connection, table_name, schema=None, **kw
@@ -523,9 +497,6 @@ def get_postgres_version(engine) -> Optional[str]:
         results = engine.execute(POSTGRES_GET_SERVER_VERSION)
         for res in results:
             version_string = str(res[0])
-            opening_parenthesis_index = version_string.find("(")
-            if opening_parenthesis_index != -1:
-                return version_string[:opening_parenthesis_index].strip()
             return version_string
     except Exception as err:
         logger.warning(f"Unable to fetch the Postgres Version - {err}")

metadata/ingestion/source/database/salesforce/metadata.py

@@ -12,7 +12,7 @@
 Salesforce source ingestion
 """
 import traceback
-from typing import Any, Iterable, Optional, Tuple
+from typing import Any, Iterable, List, Optional, Tuple
 
 from metadata.generated.schema.api.data.createDatabase import CreateDatabaseRequest
 from metadata.generated.schema.api.data.createDatabaseSchema import (
@@ -231,6 +231,29 @@ class SalesforceSource(DatabaseServiceSource):
             )
         return table_description if table_description else object_label
 
+    def get_table_column_description(self, table_name: str) -> Optional[List]:
+        """
+        Method to get the all columns' (field) description for Salesforce with the Tooling API.
+        """
+        all_column_description = None
+        try:
+            result = self.client.toolingexecute(
+                f"query/?q=SELECT+Description+FROM+FieldDefinition+WHERE+"
+                f"EntityDefinition.QualifiedApiName='{table_name}'"
+            )
+            all_column_description = result["records"]
+        except KeyError as err:
+            logger.warning(
+                "Unable to get required key from Tooling API response for "
+                f"table [{table_name}]: {err}"
+            )
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.warning(
+                f"Unable to get column description with Tooling API for table [{table_name}]: {exc}"
+            )
+        return all_column_description
+
     def yield_table(
         self, table_name_and_type: Tuple[str, TableType]
     ) -> Iterable[Either[CreateTableRequest]]:
@@ -245,7 +268,7 @@ class SalesforceSource(DatabaseServiceSource):
                 f"sobjects/{table_name}/describe/",
                 params=None,
             )
-            columns = self.get_columns(salesforce_objects.get("fields", []))
+            columns = self.get_columns(table_name, salesforce_objects.get("fields", []))
             table_request = CreateTableRequest(
                 name=EntityName(table_name),
                 tableType=table_type,
@@ -278,12 +301,26 @@ class SalesforceSource(DatabaseServiceSource):
                 )
             )
 
-    def get_columns(self, salesforce_fields):
+    def get_columns(self, table_name: str, salesforce_fields: List):
         """
         Method to handle column details
         """
         row_order = 1
         columns = []
+        column_description_mapping = {}
+        all_column_description = self.get_table_column_description(table_name)
+        if all_column_description:
+            for item in all_column_description:
+                try:
+                    if item.get("Description") is not None:
+                        column_name = item["attributes"]["url"].split(".")[-1]
+                        column_description_mapping.update(
+                            {column_name: item["Description"]}
+                        )
+                except Exception as ex:
+                    logger.debug(
+                        f"Error creating column description mapping: {str(ex)}"
+                    )
         for column in salesforce_fields:
             col_constraint = None
             if column["nillable"]:
@@ -292,11 +329,15 @@ class SalesforceSource(DatabaseServiceSource):
                 col_constraint = Constraint.NOT_NULL
             if column["unique"]:
                 col_constraint = Constraint.UNIQUE
+            if column_description_mapping.get(column["name"]):
+                column_description = column_description_mapping[column["name"]]
+            else:
+                column_description = column["label"]
 
             columns.append(
                 Column(
                     name=column["name"],
-                    description=column["label"],
+                    description=column_description,
                     dataType=self.column_type(column["type"].upper()),
                     dataTypeDisplay=column["type"],
                     constraint=col_constraint,

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

@@ -1,3 +1,6 @@
+from metadata.ingestion.source.database.singlestore.lineage import (
+    SinglestoreLineageSource,
+)
 from metadata.ingestion.source.database.singlestore.metadata import SinglestoreSource
 from metadata.profiler.interface.sqlalchemy.single_store.profiler_interface import (
     SingleStoreProfilerInterface,
@@ -5,5 +8,7 @@ from metadata.profiler.interface.sqlalchemy.single_store.profiler_interface impo
 from metadata.utils.service_spec.default import DefaultDatabaseSpec
 
 ServiceSpec = DefaultDatabaseSpec(
-    metadata_source_class=SinglestoreSource, profiler_class=SingleStoreProfilerInterface
+    metadata_source_class=SinglestoreSource,
+    profiler_class=SingleStoreProfilerInterface,
+    lineage_source_class=SinglestoreLineageSource,
 )

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

@@ -337,6 +337,8 @@ WITH SP_HISTORY AS (
     FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY SP
     WHERE QUERY_TYPE = 'CALL'
       AND START_TIME >= '{start_date}'
+      AND QUERY_TEXT <> ''
+      AND QUERY_TEXT IS NOT NULL
 ),
 Q_HISTORY AS (
     SELECT
@@ -354,6 +356,10 @@ Q_HISTORY AS (
       AND QUERY_TEXT NOT LIKE '/* {{"app": "OpenMetadata", %%}} */%%'
       AND QUERY_TEXT NOT LIKE '/* {{"app": "dbt", %%}} */%%'
       AND START_TIME >= '{start_date}'
+      AND (
+        QUERY_TYPE IN ('MERGE', 'UPDATE','CREATE_TABLE_AS_SELECT')
+        OR (QUERY_TYPE = 'INSERT' and query_text ILIKE '%%insert%%into%%select%%')
+    )
 )
 SELECT
   Q.QUERY_TYPE AS QUERY_TYPE,

metadata/ingestion/source/database/sql_column_handler.py

@@ -202,26 +202,6 @@ class SqlColumnHandlerMixin:
             ]
         return Column(**parsed_string)
 
-    @calculate_execution_time()
-    def process_json_type_column_fields(  # pylint: disable=too-many-locals
-        self, schema_name: str, table_name: str, column_name: str, inspector: Inspector
-    ) -> Optional[List[Column]]:
-        """
-        Parse fields column with json data types
-        """
-        try:
-            if hasattr(inspector, "get_json_fields_and_type"):
-                result = inspector.get_json_fields_and_type(
-                    table_name, column_name, schema_name
-                )
-                return result
-
-        except NotImplementedError:
-            logger.debug(
-                "Cannot parse json fields for table column [{schema_name}.{table_name}.{col_name}]: NotImplementedError"
-            )
-        return None
-
     @calculate_execution_time()
     def get_columns_and_constraints(  # pylint: disable=too-many-locals
         self, schema_name: str, table_name: str, db_name: str, inspector: Inspector
@@ -246,12 +226,16 @@ class SqlColumnHandlerMixin:
             if len(col) == 1:
                 column_level_unique_constraints.add(col[0])
             else:
-                table_constraints.append(
-                    TableConstraint(
-                        constraintType=ConstraintType.UNIQUE,
-                        columns=col,
+                if not any(
+                    tc.constraintType == ConstraintType.UNIQUE and tc.columns == col
+                    for tc in table_constraints
+                ):
+                    table_constraints.append(
+                        TableConstraint(
+                            constraintType=ConstraintType.UNIQUE,
+                            columns=col,
+                        )
                     )
-                )
         if len(pk_columns) > 1:
             table_constraints.append(
                 TableConstraint(
@@ -298,11 +282,6 @@ class SqlColumnHandlerMixin:
                     )
                     col_data_length = 1 if col_data_length is None else col_data_length
 
-                    if col_type == "JSON":
-                        children = self.process_json_type_column_fields(
-                            schema_name, table_name, column.get("name"), inspector
-                        )
-
                     om_column = Column(
                         name=ColumnName(
                             root=column["name"]

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

@@ -1,4 +1,8 @@
+from metadata.ingestion.source.database.sqlite.lineage import SqliteLineageSource
 from metadata.ingestion.source.database.sqlite.metadata import SqliteSource
 from metadata.utils.service_spec.default import DefaultDatabaseSpec
 
-ServiceSpec = DefaultDatabaseSpec(metadata_source_class=SqliteSource)
+ServiceSpec = DefaultDatabaseSpec(
+    metadata_source_class=SqliteSource,
+    lineage_source_class=SqliteLineageSource,
+)

metadata/ingestion/source/database/stored_procedures_mixin.py

@@ -38,10 +38,11 @@ from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.status import Status
 from metadata.ingestion.lineage.models import ConnectionTypeDialectMapper
 from metadata.ingestion.lineage.sql_lineage import get_lineage_by_query
+from metadata.ingestion.models.topology import Queue
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.utils.logger import ingestion_logger
 from metadata.utils.stored_procedures import get_procedure_name_from_call
-from metadata.utils.time_utils import convert_timestamp_to_milliseconds
+from metadata.utils.time_utils import datetime_to_timestamp
 
 logger = ingestion_logger()
 
@@ -176,8 +177,6 @@ class StoredProcedureLineageMixin(ABC):
                 timeout_seconds=self.source_config.parsingTimeoutLimit,
                 lineage_source=LineageSource.QueryLineage,
             ):
-                print("&& " * 100)
-                print(either_lineage)
                 if (
                     either_lineage.left is None
                     and either_lineage.right.edge.lineageDetails
@@ -200,8 +199,8 @@ class StoredProcedureLineageMixin(ABC):
                 query_type=query_by_procedure.query_type,
                 duration=query_by_procedure.query_duration,
                 queryDate=Timestamp(
-                    root=convert_timestamp_to_milliseconds(
-                        int(query_by_procedure.query_start_time.timestamp())
+                    root=datetime_to_timestamp(
+                        query_by_procedure.query_start_time, True
                     )
                 ),
                 triggeredBy=EntityReference(
@@ -214,37 +213,49 @@ class StoredProcedureLineageMixin(ABC):
         )
 
     def procedure_lineage_processor(
-        self, procedure_and_query: ProcedureAndQuery
+        self, procedure_and_queries: List[ProcedureAndQuery], queue: Queue
     ) -> Iterable[Either[Union[AddLineageRequest, CreateQueryRequest]]]:
-
-        try:
-            yield from self._yield_procedure_lineage(
-                query_by_procedure=procedure_and_query.query_by_procedure,
-                procedure=procedure_and_query.procedure,
-            )
-        except Exception as exc:
-            logger.debug(traceback.format_exc())
-            logger.warning(
-                f"Could not get lineage for store procedure '{procedure_and_query.procedure.fullyQualifiedName}' due to [{exc}]."
-            )
-        try:
-            yield from self.yield_procedure_query(
-                query_by_procedure=procedure_and_query.query_by_procedure,
-                procedure=procedure_and_query.procedure,
-            )
-        except Exception as exc:
-            logger.debug(traceback.format_exc())
-            logger.warning(
-                f"Could not get query for store procedure '{procedure_and_query.procedure.fullyQualifiedName}' due to [{exc}]."
-            )
+        for procedure_and_query in procedure_and_queries:
+            try:
+                for lineage in self._yield_procedure_lineage(
+                    query_by_procedure=procedure_and_query.query_by_procedure,
+                    procedure=procedure_and_query.procedure,
+                ):
+                    queue.put(lineage)
+            except Exception as exc:
+                logger.debug(traceback.format_exc())
+                logger.warning(
+                    f"Could not get lineage for store procedure '{procedure_and_query.procedure.fullyQualifiedName}' due to [{exc}]."
+                )
+            try:
+                for lineage in self.yield_procedure_query(
+                    query_by_procedure=procedure_and_query.query_by_procedure,
+                    procedure=procedure_and_query.procedure,
+                ):
+                    queue.put(lineage)
+            except Exception as exc:
+                logger.debug(traceback.format_exc())
+                logger.warning(
+                    f"Could not get query for store procedure '{procedure_and_query.procedure.fullyQualifiedName}' due to [{exc}]."
+                )
 
     def procedure_lineage_generator(self) -> Iterable[ProcedureAndQuery]:
         query = {
             "query": {
                 "bool": {
                     "must": [
-                        {"term": {"service.name.keyword": self.service_name}},
-                        {"term": {"deleted": False}},
+                        {
+                            "bool": {
+                                "should": [
+                                    {
+                                        "term": {
+                                            "service.name.keyword": self.service_name
+                                        }
+                                    }
+                                ]
+                            }
+                        },
+                        {"bool": {"should": [{"term": {"deleted": False}}]}},
                     ]
                 }
             }
@@ -256,7 +267,9 @@ class StoredProcedureLineageMixin(ABC):
         queries_dict = self.get_stored_procedure_queries_dict()
         # Then for each procedure, iterate over all its queries
         for procedure in (
-            self.metadata.paginate_es(entity=StoredProcedure, query_filter=query_filter)
+            self.metadata.paginate_es(
+                entity=StoredProcedure, query_filter=query_filter, size=10
+            )
             or []
         ):
             if procedure:

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

@@ -1,4 +1,8 @@
+from metadata.ingestion.source.database.teradata.lineage import TeradataLineageSource
 from metadata.ingestion.source.database.teradata.metadata import TeradataSource
 from metadata.utils.service_spec.default import DefaultDatabaseSpec
 
-ServiceSpec = DefaultDatabaseSpec(metadata_source_class=TeradataSource)
+ServiceSpec = DefaultDatabaseSpec(
+    metadata_source_class=TeradataSource,
+    lineage_source_class=TeradataLineageSource,
+)

metadata/ingestion/source/messaging/kafka/metadata.py

@@ -22,21 +22,19 @@ from metadata.generated.schema.metadataIngestion.workflow import (
 from metadata.ingestion.api.steps import InvalidSourceException
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.messaging.common_broker_source import CommonBrokerSource
-from metadata.utils.ssl_manager import SSLManager
+from metadata.utils.ssl_manager import SSLManager, check_ssl_and_init
 
 
 class KafkaSource(CommonBrokerSource):
     def __init__(self, config: WorkflowSource, metadata: OpenMetadata):
         self.ssl_manager = None
-        service_connection = cast(KafkaConnection, config.serviceConnection.root.config)
-        if service_connection.schemaRegistrySSL:
-            self.ssl_manager = SSLManager(
-                ca=service_connection.schemaRegistrySSL.root.caCertificate,
-                key=service_connection.schemaRegistrySSL.root.sslKey,
-                cert=service_connection.schemaRegistrySSL.root.sslCertificate,
-            )
-            service_connection = self.ssl_manager.setup_ssl(
-                config.serviceConnection.root.config
+        self.service_connection = cast(
+            KafkaConnection, config.serviceConnection.root.config
+        )
+        self.ssl_manager: SSLManager = check_ssl_and_init(self.service_connection)
+        if self.ssl_manager:
+            self.service_connection = self.ssl_manager.setup_ssl(
+                self.service_connection
             )
         super().__init__(config, metadata)
 

metadata/ingestion/source/pipeline/kafkaconnect/metadata.py

@@ -95,7 +95,7 @@ class KafkaconnectSource(PipelineServiceSource):
                 sourceUrl=connection_url,
                 tasks=[
                     Task(
-                        name=task.id,
+                        name=str(task.id),
                     )
                     for task in pipeline_details.tasks or []
                 ],
@@ -205,7 +205,7 @@ class KafkaconnectSource(PipelineServiceSource):
                     metadata=self.metadata,
                     entity_type=Topic,
                     service_name=self.service_connection.messagingServiceName,
-                    topic_name=topic.name,
+                    topic_name=str(topic.name),
                 )
 
                 topic_entity = self.metadata.get_by_name(entity=Topic, fqn=topic_fqn)
@@ -279,7 +279,7 @@ class KafkaconnectSource(PipelineServiceSource):
         try:
             task_status = [
                 TaskStatus(
-                    name=task.id,
+                    name=str(task.id),
                     executionStatus=STATUS_MAP.get(task.state, StatusType.Pending),
                 )
                 for task in pipeline_details.tasks or []

metadata/ingestion/source/pipeline/kafkaconnect/models.py

@@ -27,7 +27,7 @@ class KafkaConnectTasks(BaseModel):
         default="UNASSIGNED", description="State of the task (e.g., RUNNING, STOPPED)"
     )
     worker_id: Optional[str] = Field(
-        ..., description="ID of the worker running the task"
+        default=None, description="ID of the worker running the task"
     )
 
 
@@ -43,15 +43,15 @@ class KafkaConnectPipelineDetails(BaseModel):
         default="UNASSIGNED",
         description="State of the connector (e.g., RUNNING, STOPPED)",
     )
-    tasks: Optional[List[KafkaConnectTasks]]
-    topics: Optional[List[KafkaConnectTopics]]
-    conn_type: Optional[str] = Field(..., alias="type")
+    tasks: Optional[List[KafkaConnectTasks]] = []
+    topics: Optional[List[KafkaConnectTopics]] = []
+    conn_type: Optional[str] = Field(default="UNKNOWN", alias="type")
 
 
 class KafkaConnectDatasetDetails(BaseModel):
-    table: Optional[str]
-    database: Optional[str]
-    container_name: Optional[str]
+    table: Optional[str] = None
+    database: Optional[str] = None
+    container_name: Optional[str] = None
 
     @property
     def dataset_type(self):

metadata/ingestion/source/storage/s3/metadata.py

@@ -294,15 +294,26 @@ class S3Source(StorageServiceSource):
         )
         # if we have a sample file to fetch a schema from
         if sample_key:
-            columns = self._get_columns(
-                container_name=bucket_name,
-                sample_key=sample_key,
-                metadata_entry=metadata_entry,
-                config_source=S3Config(
-                    securityConfig=self.service_connection.awsConfig
-                ),
-                client=self.s3_client,
-            )
+            try:
+                columns = self._get_columns(
+                    container_name=bucket_name,
+                    sample_key=sample_key,
+                    metadata_entry=metadata_entry,
+                    config_source=S3Config(
+                        securityConfig=self.service_connection.awsConfig
+                    ),
+                    client=self.s3_client,
+                )
+            except Exception as err:
+                logger.warning()
+                self.status.failed(
+                    error=StackTraceError(
+                        name=f"{bucket_name}/{sample_key}",
+                        error=f"Error extracting columns from [{bucket_name}/{sample_key}] due to: [{err}]",
+                        stackTrace=traceback.format_exc(),
+                    )
+                )
+                return None
             if columns:
                 prefix = (
                     f"{KEY_SEPARATOR}{metadata_entry.dataPath.strip(KEY_SEPARATOR)}"
@@ -460,7 +471,7 @@ class S3Source(StorageServiceSource):
         candidate_keys = [
             entry["Key"]
             for entry in response[S3_CLIENT_ROOT_RESPONSE]
-            if entry and entry.get("Key")
+            if entry and entry.get("Key") and not entry.get("Key").endswith("/")
         ]
         for key in candidate_keys:
             if self.is_valid_unstructured_file(metadata_entry.unstructuredFormats, key):
@@ -669,7 +680,7 @@ class S3Source(StorageServiceSource):
                 candidate_keys = [
                     entry["Key"]
                     for entry in response[S3_CLIENT_ROOT_RESPONSE]
-                    if entry and entry.get("Key")
+                    if entry and entry.get("Key") and not entry.get("Key").endswith("/")
                 ]
                 # pick a random key out of the candidates if any were returned
                 if candidate_keys:

metadata/sampler/partition.py

@@ -49,7 +49,7 @@ def validate_athena_injected_partitioning(
 
     column_partitions: Optional[List[PartitionColumnDetails]] = table_partitions.columns
     if not column_partitions:
-        raise RuntimeError("Table parition is set but no columns are defined.")
+        raise RuntimeError("Table partition is set but no columns are defined.")
 
     for column_partition in column_partitions:
         if column_partition.intervalType == PartitionIntervalTypes.INJECTED:
@@ -163,6 +163,7 @@ def _handle_bigquery_partition(
                 partitionIntegerRangeStart=1,
                 partitionIntegerRangeEnd=10000,
             )
+        # TODO: Allow External Hive Partitioning for profiler
         raise TypeError(
             f"Unsupported partition type {partition.intervalType}. Skipping table"
         )