openmetadata-ingestion 1.6.7.0__py3-none-any.whl → 1.7.0.0rc1__py3-none-any.whl

metadata/ingestion/source/database/databricks/metadata.py

@@ -639,6 +639,8 @@ class DatabricksSource(ExternalTableLineageMixin, CommonDbSourceService, MultiDB
                     classification_name=tag_name,
                     tag_description=DATABRICKS_TAG,
                     classification_description=DATABRICKS_TAG_CLASSIFICATION,
+                    metadata=self.metadata,
+                    system_tags=True,
                 )
 
         except Exception as exc:
@@ -673,6 +675,8 @@ class DatabricksSource(ExternalTableLineageMixin, CommonDbSourceService, MultiDB
                     classification_name=tag_name,
                     tag_description=DATABRICKS_TAG,
                     classification_description=DATABRICKS_TAG_CLASSIFICATION,
+                    metadata=self.metadata,
+                    system_tags=True,
                 )
 
         except Exception as exc:
@@ -711,6 +715,8 @@ class DatabricksSource(ExternalTableLineageMixin, CommonDbSourceService, MultiDB
                     classification_name=tag_name,
                     tag_description=DATABRICKS_TAG,
                     classification_description=DATABRICKS_TAG_CLASSIFICATION,
+                    metadata=self.metadata,
+                    system_tags=True,
                 )
 
             column_tags = self.column_tags.get(
@@ -737,6 +743,8 @@ class DatabricksSource(ExternalTableLineageMixin, CommonDbSourceService, MultiDB
                         classification_name=tag_name,
                         tag_description=DATABRICKS_TAG,
                         classification_description=DATABRICKS_TAG_CLASSIFICATION,
+                        metadata=self.metadata,
+                        system_tags=True,
                     )
 
         except Exception as exc:

metadata/ingestion/source/database/datalake/metadata.py

@@ -129,9 +129,11 @@ class DatalakeSource(DatabaseServiceSource):
             )
             if filter_by_database(
                 self.source_config.databaseFilterPattern,
-                database_fqn
-                if self.source_config.useFqnForFiltering
-                else database_name,
+                (
+                    database_fqn
+                    if self.source_config.useFqnForFiltering
+                    else database_name
+                ),
             ):
                 self.status.filter(database_fqn, "Database Filtered out")
             else:
@@ -180,9 +182,11 @@ class DatalakeSource(DatabaseServiceSource):
 
                 if filter_by_schema(
                     self.config.sourceConfig.config.schemaFilterPattern,
-                    schema_fqn
-                    if self.config.sourceConfig.config.useFqnForFiltering
-                    else schema_name,
+                    (
+                        schema_fqn
+                        if self.config.sourceConfig.config.useFqnForFiltering
+                        else schema_name
+                    ),
                 ):
                     self.status.filter(schema_fqn, "Bucket Filtered Out")
                     continue
@@ -352,9 +356,11 @@ class DatalakeSource(DatabaseServiceSource):
 
         if filter_by_table(
             self.config.sourceConfig.config.tableFilterPattern,
-            table_fqn
-            if self.config.sourceConfig.config.useFqnForFiltering
-            else table_name,
+            (
+                table_fqn
+                if self.config.sourceConfig.config.useFqnForFiltering
+                else table_name
+            ),
         ):
             self.status.filter(
                 table_fqn,

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

@@ -1,3 +1,4 @@
+from metadata.ingestion.source.database.db2.lineage import Db2LineageSource
 from metadata.ingestion.source.database.db2.metadata import Db2Source
 from metadata.profiler.interface.sqlalchemy.db2.profiler_interface import (
     DB2ProfilerInterface,
@@ -5,5 +6,7 @@ from metadata.profiler.interface.sqlalchemy.db2.profiler_interface import (
 from metadata.utils.service_spec.default import DefaultDatabaseSpec
 
 ServiceSpec = DefaultDatabaseSpec(
-    metadata_source_class=Db2Source, profiler_class=DB2ProfilerInterface
+    metadata_source_class=Db2Source,
+    profiler_class=DB2ProfilerInterface,
+    lineage_source_class=Db2LineageSource,
 )

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

@@ -255,6 +255,7 @@ def get_blobs_grouped_by_dir(blobs: List[str]) -> Dict[str, List[str]]:
             DBT_MANIFEST_FILE_NAME == blob_file_name.lower()
             or DBT_CATALOG_FILE_NAME == blob_file_name.lower()
             or DBT_RUN_RESULTS_FILE_NAME in blob_file_name.lower()
+            or DBT_SOURCES_FILE_NAME == blob_file_name.lower()
         ):
             blob_grouped_by_directory[subdirectory].append(blob)
     return blob_grouped_by_directory

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

@@ -142,7 +142,7 @@ def get_dbt_raw_query(mnode) -> Optional[str]:
         return mnode.raw_code
     if hasattr(mnode, RawQueriesEnum.RAW_SQL.value) and mnode.raw_sql:
         return mnode.raw_sql
-    logger.debug(f"Unable to get DBT compiled query for node - {mnode.name}")
+    logger.debug(f"Unable to get DBT raw query for node - {mnode.name}")
     return None
 
 

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

@@ -367,7 +367,11 @@ class DbtSource(DbtServiceSource):
             logger.debug(
                 f"Found table entities from {fqn_search_string}: {table_entities}"
             )
-            return next(iter(filter(None, table_entities)), None)
+            return (
+                next(iter(filter(None, table_entities)), None)
+                if table_entities
+                else None
+            )
 
         try:
             table_entity = search_table(table_fqn)

metadata/ingestion/source/database/doris/metadata.py

@@ -224,8 +224,13 @@ class DorisSource(CommonDbSourceService):
 
         return table_columns, primary_columns
 
-    def get_columns_and_constraints(
-        self, schema_name: str, table_name: str, db_name: str, inspector: Inspector
+    def get_columns_and_constraints(  # pylint: disable=too-many-locals
+        self,
+        schema_name: str,
+        table_name: str,
+        db_name: str,
+        inspector: Inspector,
+        table_type: str = None,
     ) -> Tuple[
         Optional[List[Column]], Optional[List[TableConstraint]], Optional[List[Dict]]
     ]:

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

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

metadata/ingestion/source/database/dynamodb/metadata.py

@@ -13,7 +13,7 @@ Dynamo source methods.
 """
 
 import traceback
-from typing import Dict, List, Optional, Union
+from typing import Dict, Iterable, List, Optional, Union
 
 from metadata.generated.schema.entity.data.table import TableType
 from metadata.generated.schema.entity.services.connections.database.dynamoDBConnection import (
@@ -27,6 +27,7 @@ from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.database.common_nosql_source import (
     SAMPLE_SIZE,
     CommonNoSQLSource,
+    TableNameAndType,
 )
 from metadata.ingestion.source.database.dynamodb.models import TableResponse
 from metadata.utils.constants import DEFAULT_DATABASE
@@ -64,14 +65,16 @@ class DynamodbSource(CommonNoSQLSource):
         """
         return [DEFAULT_DATABASE]
 
-    def get_table_name_list(self, schema_name: str) -> List[str]:
+    def query_table_names_and_types(
+        self, schema_name: str
+    ) -> Iterable[TableNameAndType]:
         """
         Method to get list of table names available within schema db
         need to be overridden by sources
         """
         try:
             tables = self.dynamodb.tables.all()
-            return [table.name for table in tables]
+            return [TableNameAndType(name=table.name) for table in tables]
         except Exception as err:
             logger.debug(traceback.format_exc())
             logger.error(f"Failed to list DynamoDB table names: {err}")

metadata/ingestion/source/database/greenplum/metadata.py

@@ -16,7 +16,7 @@ from collections import namedtuple
 from typing import Iterable, Optional, Tuple
 
 from sqlalchemy import sql
-from sqlalchemy.dialects.postgresql.base import PGDialect, ischema_names
+from sqlalchemy.dialects.postgresql.base import PGDialect
 from sqlalchemy.engine.reflection import Inspector
 
 from metadata.generated.schema.entity.data.database import Database
@@ -36,11 +36,15 @@ from metadata.generated.schema.metadataIngestion.workflow import (
     Source as WorkflowSource,
 )
 from metadata.ingestion.api.steps import InvalidSourceException
-from metadata.ingestion.source.database.column_type_parser import create_sqlalchemy_type
 from metadata.ingestion.source.database.common_db_source import (
     CommonDbSourceService,
     TableNameAndType,
 )
+from metadata.ingestion.source.database.common_pg_mappings import (
+    INTERVAL_TYPE_MAP,
+    RELKIND_MAP,
+    ischema_names,
+)
 from metadata.ingestion.source.database.greenplum.queries import (
     GREENPLUM_GET_DB_NAMES,
     GREENPLUM_GET_TABLE_NAMES,
@@ -66,41 +70,6 @@ TableKey = namedtuple("TableKey", ["schema", "table_name"])
 logger = ingestion_logger()
 
 
-INTERVAL_TYPE_MAP = {
-    "list": PartitionIntervalTypes.COLUMN_VALUE,
-    "hash": PartitionIntervalTypes.COLUMN_VALUE,
-    "range": PartitionIntervalTypes.TIME_UNIT,
-}
-
-RELKIND_MAP = {
-    "r": TableType.Regular,
-    "p": TableType.Partitioned,
-    "f": TableType.Foreign,
-}
-
-GEOMETRY = create_sqlalchemy_type("GEOMETRY")
-POINT = create_sqlalchemy_type("POINT")
-POLYGON = create_sqlalchemy_type("POLYGON")
-
-ischema_names.update(
-    {
-        "geometry": GEOMETRY,
-        "point": POINT,
-        "polygon": POLYGON,
-        "box": create_sqlalchemy_type("BOX"),
-        "circle": create_sqlalchemy_type("CIRCLE"),
-        "line": create_sqlalchemy_type("LINE"),
-        "lseg": create_sqlalchemy_type("LSEG"),
-        "path": create_sqlalchemy_type("PATH"),
-        "pg_lsn": create_sqlalchemy_type("PG_LSN"),
-        "pg_snapshot": create_sqlalchemy_type("PG_SNAPSHOT"),
-        "tsquery": create_sqlalchemy_type("TSQUERY"),
-        "txid_snapshot": create_sqlalchemy_type("TXID_SNAPSHOT"),
-        "xml": create_sqlalchemy_type("XML"),
-    }
-)
-
-
 PGDialect.get_all_table_comments = get_all_table_comments
 PGDialect.get_table_comment = get_table_comment
 PGDialect._get_column_info = get_column_info  # pylint: disable=protected-access

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

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

metadata/ingestion/source/database/hive/metastore_dialects/mysql/dialect.py

@@ -45,21 +45,43 @@ class HiveMysqlMetaStoreDialect(HiveMetaStoreDialectMixin, MySQLDialect_pymysql)
         return [row[0] for row in connection.execute(query)]
 
     def _get_table_columns(self, connection, table_name, schema):
+        schema_join = (
+            f"""
+            JOIN DBS db on tbsl.DB_ID = db.DB_ID
+            AND db.NAME = '{schema}'
+        """
+            if schema
+            else ""
+        )
+
         query = f"""
-            SELECT 
-                col.COLUMN_NAME, 
-                col.TYPE_NAME,
-                col.COMMENT
-            from 
-                COLUMNS_V2 col 
-                join CDS cds ON col.CD_ID = cds.CD_ID 
-                join SDS sds ON sds.CD_ID = cds.CD_ID 
-                join TBLS tbsl on sds.SD_ID = tbsl.SD_ID 
-                and tbsl.TBL_NAME = '{table_name}'
+            WITH regular_columns AS (
+                SELECT 
+                    col.COLUMN_NAME,
+                    col.TYPE_NAME, 
+                    col.COMMENT
+                FROM COLUMNS_V2 col
+                JOIN CDS cds ON col.CD_ID = cds.CD_ID
+                JOIN SDS sds ON sds.CD_ID = cds.CD_ID
+                JOIN TBLS tbsl ON sds.SD_ID = tbsl.SD_ID
+                    AND tbsl.TBL_NAME = '{table_name}'
+                            {schema_join}
+                        ),
+                        partition_columns AS (
+                SELECT 
+                    pk.PKEY_NAME as COLUMN_NAME,
+                    pk.PKEY_TYPE as TYPE_NAME,
+                    pk.PKEY_COMMENT as COMMENT
+                FROM PARTITION_KEYS pk
+                JOIN TBLS tbsl ON pk.TBL_ID = tbsl.TBL_ID
+                    AND tbsl.TBL_NAME = '{table_name}'
+                {schema_join}
+            )
+            -- Combine regular and partition columns
+            SELECT * FROM regular_columns
+            UNION ALL
+            SELECT * FROM partition_columns
         """
-        if schema:
-            query += f""" join DBS db on tbsl.DB_ID = db.DB_ID
-            and db.NAME = '{schema}'"""
 
         return connection.execute(query).fetchall()
 

metadata/ingestion/source/database/hive/metastore_dialects/postgres/dialect.py

@@ -46,22 +46,46 @@ class HivePostgresMetaStoreDialect(HiveMetaStoreDialectMixin, PGDialect_psycopg2
         return [row[0] for row in connection.execute(query)]
 
     def _get_table_columns(self, connection, table_name, schema):
-        query = f"""
-            SELECT 
-                col."COLUMN_NAME", 
-                col."TYPE_NAME",
-                col."COMMENT"
-            from 
-                "COLUMNS_V2" col 
-                join "CDS" cds ON col."CD_ID" = cds."CD_ID" 
-                join "SDS" sds ON sds."CD_ID" = cds."CD_ID" 
-                join "TBLS" tbsl on sds."SD_ID" = tbsl."SD_ID" 
-                and tbsl."TBL_NAME" = '{table_name}'
+        # Build schema join clause if schema is provided
+        schema_join = (
+            f"""
+            JOIN "DBS" db on tbsl."DB_ID" = db."DB_ID"
+            AND db."NAME" = '{schema}'
         """
-        if schema:
-            query += f""" join "DBS" db on tbsl."DB_ID" = db."DB_ID"
-            and db."NAME" = '{schema}'"""
+            if schema
+            else ""
+        )
 
+        query = f"""
+            WITH regular_columns AS (
+                -- Get regular table columns from COLUMNS_V2
+                SELECT 
+                    col."COLUMN_NAME",
+                    col."TYPE_NAME", 
+                    col."COMMENT"
+                FROM "COLUMNS_V2" col
+                JOIN "CDS" cds ON col."CD_ID" = cds."CD_ID"
+                JOIN "SDS" sds ON sds."CD_ID" = cds."CD_ID"
+                JOIN "TBLS" tbsl ON sds."SD_ID" = tbsl."SD_ID"
+                    AND tbsl."TBL_NAME" = '{table_name}'
+                {schema_join}
+            ),
+            partition_columns AS (
+                -- Get partition key columns from PARTITION_KEYS
+                SELECT 
+                    pk."PKEY_NAME" as "COLUMN_NAME",
+                    pk."PKEY_TYPE" as "TYPE_NAME",
+                    pk."PKEY_COMMENT" as "COMMENT"
+                FROM "PARTITION_KEYS" pk
+                JOIN "TBLS" tbsl ON pk."TBL_ID" = tbsl."TBL_ID"
+                    AND tbsl."TBL_NAME" = '{table_name}'
+                {schema_join}
+            )
+            -- Combine regular and partition columns
+            SELECT * FROM regular_columns
+            UNION ALL
+            SELECT * FROM partition_columns
+        """
         return connection.execute(query).fetchall()
 
     def _get_table_names_base_query(self, schema=None):

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

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

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

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

metadata/ingestion/source/database/life_cycle_query_mixin.py

@@ -101,15 +101,19 @@ class LifeCycleQueryMixin:
         try:
             life_cycle_data = self.life_cycle_query_dict(query=query).get(entity_name)
             if life_cycle_data:
-                life_cycle = LifeCycle(
-                    created=AccessDetails(
-                        timestamp=Timestamp(
-                            datetime_to_timestamp(
-                                life_cycle_data.created_at, milliseconds=True
-                            )
-                        )
+                if life_cycle_data.created_at:
+                    timestamp_value = datetime_to_timestamp(
+                        life_cycle_data.created_at, milliseconds=True
                     )
+                else:
+                    timestamp_value = datetime_to_timestamp(
+                        datetime.min, milliseconds=True
+                    )  # Using minimum date
+
+                life_cycle = LifeCycle(
+                    created=AccessDetails(timestamp=Timestamp(timestamp_value))
                 )
+
                 yield Either(
                     right=OMetaLifeCycleData(
                         entity=entity, entity_fqn=entity_fqn, life_cycle=life_cycle

metadata/ingestion/source/database/lineage_source.py

@@ -18,15 +18,28 @@ import traceback
 from abc import ABC
 from concurrent.futures import ThreadPoolExecutor
 from functools import partial
-from typing import Any, Callable, Iterable, Iterator, List, Union
+from typing import Any, Callable, Iterable, Iterator, List, Optional, Union
 
 from metadata.generated.schema.api.data.createQuery import CreateQueryRequest
 from metadata.generated.schema.api.lineage.addLineage import AddLineageRequest
-from metadata.generated.schema.type.basic import FullyQualifiedEntityName, SqlQuery
+from metadata.generated.schema.entity.data.table import Table
+from metadata.generated.schema.type.basic import (
+    FullyQualifiedEntityName,
+    SqlQuery,
+    Uuid,
+)
+from metadata.generated.schema.type.entityLineage import (
+    ColumnLineage,
+    EntitiesEdge,
+    LineageDetails,
+    Source,
+)
+from metadata.generated.schema.type.entityReference import EntityReference
 from metadata.generated.schema.type.tableQuery import TableQuery
 from metadata.ingestion.api.models import Either
 from metadata.ingestion.lineage.models import ConnectionTypeDialectMapper, Dialect
 from metadata.ingestion.lineage.sql_lineage import (
+    get_column_fqn,
     get_lineage_by_graph,
     get_lineage_by_query,
 )
@@ -317,6 +330,62 @@ class LineageSource(QueryParserSource, ABC):
             f"Processing Procedure Lineage not supported for {str(self.service_connection.type.value)}"
         )
 
+    def get_column_lineage(
+        self, from_table: Table, to_table: Table
+    ) -> List[ColumnLineage]:
+        """
+        Get the column lineage from the fields
+        """
+        try:
+            column_lineage = []
+            for column in from_table.columns:
+                field = column.name.root
+                from_column = get_column_fqn(table_entity=from_table, column=field)
+                to_column = get_column_fqn(table_entity=to_table, column=field)
+                if from_column and to_column:
+                    column_lineage.append(
+                        ColumnLineage(fromColumns=[from_column], toColumn=to_column)
+                    )
+
+            return column_lineage
+        except Exception as exc:
+            logger.debug(f"Error to get column lineage: {exc}")
+            logger.debug(traceback.format_exc())
+
+    def get_add_cross_database_lineage_request(
+        self,
+        from_entity: Table,
+        to_entity: Table,
+        column_lineage: List[ColumnLineage] = None,
+    ) -> Optional[Either[AddLineageRequest]]:
+        if from_entity and to_entity:
+            return Either(
+                right=AddLineageRequest(
+                    edge=EntitiesEdge(
+                        fromEntity=EntityReference(
+                            id=Uuid(from_entity.id.root), type="table"
+                        ),
+                        toEntity=EntityReference(
+                            id=Uuid(to_entity.id.root), type="table"
+                        ),
+                        lineageDetails=LineageDetails(
+                            source=Source.CrossDatabaseLineage,
+                            columnsLineage=column_lineage,
+                        ),
+                    )
+                )
+            )
+
+        return None
+
+    def yield_cross_database_lineage(self) -> Iterable[Either[AddLineageRequest]]:
+        """
+        By default cross database lineage is not supported.
+        """
+        logger.info(
+            f"Processing Cross Database Lineage not supported for {str(self.service_connection.type.value)}"
+        )
+
     def _iter(
         self, *_, **__
     ) -> Iterable[Either[Union[AddLineageRequest, CreateQueryRequest]]]:
@@ -338,3 +407,8 @@ class LineageSource(QueryParserSource, ABC):
                 logger.warning(
                     f"Lineage extraction is not supported for {str(self.service_connection.type.value)} connection"
                 )
+        if (
+            self.source_config.processCrossDatabaseLineage
+            and self.source_config.crossDatabaseServiceNames
+        ):
+            yield from self.yield_cross_database_lineage() or []

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

@@ -1,4 +1,12 @@
+from metadata.ingestion.source.database.mariadb.lineage import MariadbLineageSource
 from metadata.ingestion.source.database.mariadb.metadata import MariadbSource
+from metadata.profiler.interface.sqlalchemy.mariadb.profiler_interface import (
+    MariaDBProfilerInterface,
+)
 from metadata.utils.service_spec.default import DefaultDatabaseSpec
 
-ServiceSpec = DefaultDatabaseSpec(metadata_source_class=MariadbSource)
+ServiceSpec = DefaultDatabaseSpec(
+    metadata_source_class=MariadbSource,
+    lineage_source_class=MariadbLineageSource,
+    profiler_class=MariaDBProfilerInterface,
+)

metadata/ingestion/source/database/mongodb/metadata.py

@@ -13,7 +13,7 @@ MongoDB source methods.
 """
 
 import traceback
-from typing import Dict, List, Optional, Union
+from typing import Dict, Iterable, List, Optional, Union
 
 from pymongo.errors import OperationFailure
 
@@ -28,6 +28,7 @@ from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.database.common_nosql_source import (
     SAMPLE_SIZE,
     CommonNoSQLSource,
+    TableNameAndType,
 )
 from metadata.utils.logger import ingestion_logger
 
@@ -68,14 +69,18 @@ class MongodbSource(CommonNoSQLSource):
             logger.debug(traceback.format_exc())
         return []
 
-    def get_table_name_list(self, schema_name: str) -> List[str]:
+    def query_table_names_and_types(
+        self, schema_name: str
+    ) -> Iterable[TableNameAndType]:
         """
         Method to get list of table names available within schema db
         need to be overridden by sources
         """
         try:
             database = self.mongodb.get_database(schema_name)
-            return database.list_collection_names()
+            return [
+                TableNameAndType(name=name) for name in database.list_collection_names()
+            ]
         except Exception as exp:
             logger.debug(
                 f"Failed to list collection names for schema [{schema_name}]: {exp}"