openmetadata-ingestion 1.9.12.0__py3-none-any.whl → 1.10.0.0__py3-none-any.whl

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

@@ -0,0 +1,99 @@
+#  Copyright 2025 Collate
+#  Licensed under the Collate Community License, Version 1.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  https://github.com/open-metadata/OpenMetadata/blob/main/ingestion/LICENSE
+#  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.
+
+"""
+This module provides authentication utilities for Databricks and Unity Catalog connections.
+"""
+from typing import Union
+
+from databricks.sdk.core import Config, azure_service_principal, oauth_service_principal
+
+from metadata.generated.schema.entity.services.connections.database.databricks.azureAdSetup import (
+    AzureAdSetup,
+)
+from metadata.generated.schema.entity.services.connections.database.databricks.databricksOAuth import (
+    DatabricksOauth,
+)
+from metadata.generated.schema.entity.services.connections.database.databricks.personalAccessToken import (
+    PersonalAccessToken,
+)
+from metadata.generated.schema.entity.services.connections.database.databricksConnection import (
+    DatabricksConnection,
+)
+from metadata.generated.schema.entity.services.connections.database.unityCatalogConnection import (
+    UnityCatalogConnection,
+)
+
+
+def get_personal_access_token_auth(
+    connection: Union[DatabricksConnection, UnityCatalogConnection],
+) -> dict:
+    """
+    Configure Personal Access Token authentication
+    """
+    return {"access_token": connection.authType.token.get_secret_value()}
+
+
+def get_databricks_oauth_auth(
+    connection: Union[DatabricksConnection, UnityCatalogConnection],
+):
+    """
+    Create Databricks OAuth2 M2M credentials provider for Service Principal authentication
+    """
+
+    def credential_provider():
+        hostname = connection.hostPort.split(":")[0]
+        config = Config(
+            host=f"https://{hostname}",
+            client_id=connection.authType.clientId,
+            client_secret=connection.authType.clientSecret.get_secret_value(),
+        )
+        return oauth_service_principal(config)
+
+    return {"credentials_provider": credential_provider}
+
+
+def get_azure_ad_auth(connection: Union[DatabricksConnection, UnityCatalogConnection]):
+    """
+    Create Azure AD credentials provider for Azure Service Principal authentication
+    """
+
+    def credential_provider():
+        hostname = connection.hostPort.split(":")[0]
+        config = Config(
+            host=f"https://{hostname}",
+            azure_client_secret=connection.authType.azureClientSecret.get_secret_value(),
+            azure_client_id=connection.authType.azureClientId,
+            azure_tenant_id=connection.authType.azureTenantId,
+        )
+        return azure_service_principal(config)
+
+    return {"credentials_provider": credential_provider}
+
+
+def get_auth_config(
+    connection: Union[DatabricksConnection, UnityCatalogConnection],
+) -> dict:
+    """
+    Get authentication configuration for Databricks connection
+    """
+    auth_method = {
+        PersonalAccessToken: get_personal_access_token_auth,
+        DatabricksOauth: get_databricks_oauth_auth,
+        AzureAdSetup: get_azure_ad_auth,
+    }.get(type(connection.authType))
+
+    if not auth_method:
+        raise ValueError(
+            f"Unsupported authentication type: {type(connection.authType)}"
+        )
+
+    return auth_method(connection)

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

@@ -61,14 +61,13 @@ class DatabricksClient:
     ):
         self.config = config
         base_url, *_ = self.config.hostPort.split(":")
-        auth_token = self.config.token.get_secret_value()
         self.base_url = f"https://{base_url}{API_VERSION}"
         self.base_query_url = f"{self.base_url}{QUERIES_PATH}"
         self.base_job_url = f"https://{base_url}{JOB_API_VERSION}/jobs"
         self.jobs_list_url = f"{self.base_job_url}/list"
         self.jobs_run_list_url = f"{self.base_job_url}/runs/list"
         self.headers = {
-            "Authorization": f"Bearer {auth_token}",
+            **self._get_auth_header(),
             "Content-Type": "application/json",
         }
         self.api_timeout = self.config.connectionTimeout or 120
@@ -81,6 +80,12 @@ class DatabricksClient:
         self.engine = engine
         self.client = requests
 
+    def _get_auth_header(self) -> dict[str, str]:
+        """
+        Method to get auth header
+        """
+        return {"Authorization": f"Bearer {self.config.token.get_secret_value()}"}
+
     def test_query_api_access(self) -> None:
         res = self.client.get(
             self.base_query_url, headers=self.headers, timeout=self.api_timeout

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

@@ -12,6 +12,7 @@
 """
 Source connection handler
 """
+from copy import deepcopy
 from functools import partial
 from typing import Optional
 
@@ -38,9 +39,17 @@ from metadata.ingestion.connections.test_connections import (
     test_connection_steps,
 )
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
+from metadata.ingestion.source.database.databricks.auth import get_auth_config
 from metadata.ingestion.source.database.databricks.queries import (
     DATABRICKS_GET_CATALOGS,
     DATABRICKS_SQL_STATEMENT_TEST,
+    TEST_CATALOG_TAGS,
+    TEST_COLUMN_LINEAGE,
+    TEST_COLUMN_TAGS,
+    TEST_SCHEMA_TAGS,
+    TEST_TABLE_LINEAGE,
+    TEST_TABLE_TAGS,
+    TEST_VIEW_DEFINITIONS,
 )
 from metadata.utils.constants import THREE_MIN
 from metadata.utils.logger import ingestion_logger
@@ -122,8 +131,7 @@ class DatabricksEngineWrapper:
 
 
 def get_connection_url(connection: DatabricksConnection) -> str:
-    url = f"{connection.scheme.value}://token:{connection.token.get_secret_value()}@{connection.hostPort}"
-    return url
+    return f"{connection.scheme.value}://{connection.hostPort}"
 
 
 def get_connection(connection: DatabricksConnection) -> Engine:
@@ -131,17 +139,27 @@ def get_connection(connection: DatabricksConnection) -> Engine:
     Create connection
     """
 
+    if not connection.connectionArguments:
+        connection.connectionArguments = init_empty_connection_arguments()
+
     if connection.httpPath:
-        if not connection.connectionArguments:
-            connection.connectionArguments = init_empty_connection_arguments()
         connection.connectionArguments.root["http_path"] = connection.httpPath
 
-    return create_generic_db_connection(
+    auth_args = get_auth_config(connection)
+
+    original_connection_arguments = connection.connectionArguments
+    connection.connectionArguments = deepcopy(original_connection_arguments)
+    connection.connectionArguments.root.update(auth_args)
+
+    engine = create_generic_db_connection(
         connection=connection,
         get_connection_url_fn=get_connection_url,
         get_connection_args_fn=get_connection_args_common,
     )
 
+    connection.connectionArguments = original_connection_arguments
+    return engine
+
 
 def test_connection(
     metadata: OpenMetadata,
@@ -170,6 +188,11 @@ def test_connection(
     # Create wrapper to avoid multiple schema calls
     engine_wrapper = DatabricksEngineWrapper(connection)
 
+    # Helper function to get first catalog for tag queries
+    def get_first_catalog():
+        catalogs = engine_wrapper.get_catalogs(catalog_name=service_connection.catalog)
+        return catalogs[0] if catalogs else service_connection.catalog or "main"
+
     test_fn = {
         "CheckAccess": partial(test_connection_engine_step, connection),
         "GetSchemas": partial(
@@ -187,6 +210,41 @@ def test_connection(
                 query_history=service_connection.queryHistoryTable
             ),
         ),
+        "GetViewDefinitions": partial(
+            test_database_query,
+            engine=connection,
+            statement=TEST_VIEW_DEFINITIONS,
+        ),
+        "GetCatalogTags": partial(
+            test_database_query,
+            engine=connection,
+            statement=TEST_CATALOG_TAGS.format(database_name=get_first_catalog()),
+        ),
+        "GetSchemaTags": partial(
+            test_database_query,
+            engine=connection,
+            statement=TEST_SCHEMA_TAGS.format(database_name=get_first_catalog()),
+        ),
+        "GetTableTags": partial(
+            test_database_query,
+            engine=connection,
+            statement=TEST_TABLE_TAGS.format(database_name=get_first_catalog()),
+        ),
+        "GetColumnTags": partial(
+            test_database_query,
+            engine=connection,
+            statement=TEST_COLUMN_TAGS.format(database_name=get_first_catalog()),
+        ),
+        "GetTableLineage": partial(
+            test_database_query,
+            engine=connection,
+            statement=TEST_TABLE_LINEAGE,
+        ),
+        "GetColumnLineage": partial(
+            test_database_query,
+            engine=connection,
+            statement=TEST_COLUMN_LINEAGE,
+        ),
     }
 
     return test_connection_steps(

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

@@ -114,3 +114,64 @@ DATABRICKS_GET_COLUMN_LINEAGE_FOR_JOB = textwrap.dedent(
         AND event_time >= current_date() - INTERVAL 90 DAYS
     """
 )
+
+# Test connection queries
+TEST_VIEW_DEFINITIONS = textwrap.dedent(
+    """
+    SELECT
+        TABLE_NAME,
+        TABLE_SCHEMA,
+        VIEW_DEFINITION
+    FROM INFORMATION_SCHEMA.VIEWS
+    WHERE VIEW_DEFINITION IS NOT NULL
+    LIMIT 1
+    """
+)
+
+TEST_CATALOG_TAGS = textwrap.dedent(
+    """
+    SELECT COUNT(*) as count
+    FROM `{database_name}`.information_schema.catalog_tags
+    WHERE 1=0
+    """
+)
+
+TEST_SCHEMA_TAGS = textwrap.dedent(
+    """
+    SELECT COUNT(*) as count
+    FROM `{database_name}`.information_schema.schema_tags
+    WHERE 1=0
+    """
+)
+
+TEST_TABLE_TAGS = textwrap.dedent(
+    """
+    SELECT COUNT(*) as count
+    FROM `{database_name}`.information_schema.table_tags
+    WHERE 1=0
+    """
+)
+
+TEST_COLUMN_TAGS = textwrap.dedent(
+    """
+    SELECT COUNT(*) as count
+    FROM `{database_name}`.information_schema.column_tags
+    WHERE 1=0
+    """
+)
+
+TEST_TABLE_LINEAGE = textwrap.dedent(
+    """
+    SELECT COUNT(*) as count
+    FROM system.access.table_lineage
+    WHERE 1=0
+    """
+)
+
+TEST_COLUMN_LINEAGE = textwrap.dedent(
+    """
+    SELECT COUNT(*) as count
+    FROM system.access.column_lineage
+    WHERE 1=0
+    """
+)

metadata/ingestion/source/database/iceberg/metadata.py

@@ -11,6 +11,7 @@
 """
 Iceberg source methods.
 """
+import time
 import traceback
 from typing import Any, Iterable, Optional, Tuple
 
@@ -169,6 +170,43 @@ class IcebergSource(DatabaseServiceSource):
         yield Either(right=schema_request)
         self.register_record_schema_request(schema_request=schema_request)
 
+    def _load_iceberg_table(self, table_identifier: str):
+        """
+        load iceberg table properly with handling
+        network connection error
+        """
+        try:
+            from botocore.exceptions import EndpointConnectionError
+
+            # Add retry logic for transient network issues
+            max_retries = 3
+            retry_delay = 1
+
+            for attempt in range(max_retries):
+                try:
+                    table = self.iceberg.load_table(table_identifier)
+                    # Success, exit retry loop
+                    return table
+                except (OSError, EndpointConnectionError) as e:
+                    if "Couldn't resolve host name" in str(
+                        e
+                    ) or "NETWORK_CONNECTION" in str(e):
+                        if attempt < max_retries - 1:
+                            logger.warning(
+                                f"Network error loading table {table_identifier}, "
+                                f"retrying in {retry_delay} seconds (attempt {attempt + 1}/{max_retries}): {e}"
+                            )
+                            time.sleep(retry_delay)
+                            retry_delay *= 2  # Exponential backoff
+                        else:
+                            logger.warning(f"Maximum retries reached::: {exc}")
+                    else:
+                        logger.warning(f"Other error than host connection::: {exc}")
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.warning(f"Could not load iceberg table properly {exc}")
+        return None
+
     def get_tables_name_and_type(self) -> Optional[Iterable[Tuple[str, str]]]:
         """
         Prepares the table name to be sent to stage.
@@ -178,9 +216,14 @@ class IcebergSource(DatabaseServiceSource):
 
         for table_identifier in self.iceberg.list_tables(namespace):
             try:
-                table = self.iceberg.load_table(table_identifier)
+                table = self._load_iceberg_table(table_identifier)
                 # extract table name from table identifier, which does not include catalog name
                 table_name = get_table_name_as_str(table_identifier)
+                if not table:
+                    logger.debug(
+                        f"iceberg Table could not be fetched for table name = {table_name}"
+                    )
+                    continue
                 table_fqn = fqn.build(
                     self.metadata,
                     entity_type=Table,

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

@@ -11,21 +11,44 @@
 """
 MariaDB source module
 """
-from typing import Optional
+import traceback
+from typing import Iterable, Optional
 
 from sqlalchemy.dialects.mysql.base import ischema_names
 from sqlalchemy.dialects.mysql.reflection import MySQLTableDefinitionParser
 
+from metadata.generated.schema.api.data.createStoredProcedure import (
+    CreateStoredProcedureRequest,
+)
+from metadata.generated.schema.entity.data.databaseSchema import DatabaseSchema
+from metadata.generated.schema.entity.data.storedProcedure import StoredProcedureCode
 from metadata.generated.schema.entity.services.connections.database.mariaDBConnection import (
     MariaDBConnection,
 )
+from metadata.generated.schema.entity.services.ingestionPipelines.status import (
+    StackTraceError,
+)
 from metadata.generated.schema.metadataIngestion.workflow import (
     Source as WorkflowSource,
 )
+from metadata.generated.schema.type.basic import EntityName, Markdown
+from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import InvalidSourceException
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.database.common_db_source import CommonDbSourceService
+from metadata.ingestion.source.database.mariadb.models import (
+    ROUTINE_TYPE_MAP,
+    MariaDBStoredProcedure,
+)
+from metadata.ingestion.source.database.mariadb.queries import (
+    MARIADB_GET_FUNCTIONS,
+    MARIADB_GET_STORED_PROCEDURES,
+)
 from metadata.ingestion.source.database.mysql.utils import col_type_map, parse_column
+from metadata.utils import fqn
+from metadata.utils.logger import ingestion_logger
+
+logger = ingestion_logger()
 
 ischema_names.update(col_type_map)
 
@@ -52,3 +75,65 @@ class MariadbSource(CommonDbSourceService):
                 f"Expected MariaDBConnection, but got {connection}"
             )
         return cls(config, metadata)
+
+    def _get_stored_procedures_internal(
+        self, query: str
+    ) -> Iterable[MariaDBStoredProcedure]:
+        results = self.engine.execute(query).all()
+        for row in results:
+            try:
+                yield MariaDBStoredProcedure.model_validate(dict(row._mapping))
+            except Exception as exc:
+                error = f"Error parsing Stored Procedure payload: {exc}"
+                logger.error(error)
+                self.status.failed(
+                    error=StackTraceError(
+                        name=dict(row).get("procedure_name", "UNKNOWN"),
+                        error=error,
+                        stackTrace=traceback.format_exc(),
+                    )
+                )
+
+    def get_stored_procedures(self) -> Iterable[MariaDBStoredProcedure]:
+        """List stored procedures"""
+        if self.source_config.includeStoredProcedures:
+            for query in (MARIADB_GET_STORED_PROCEDURES, MARIADB_GET_FUNCTIONS):
+                yield from self._get_stored_procedures_internal(
+                    query.format(schema_name=self.context.get().database_schema)
+                )
+
+    def yield_stored_procedure(
+        self, stored_procedure
+    ) -> Iterable[Either[CreateStoredProcedureRequest]]:
+        """Prepare the stored procedure payload"""
+        try:
+            stored_procedure_request = CreateStoredProcedureRequest(
+                name=EntityName(stored_procedure.name),
+                description=(
+                    Markdown(stored_procedure.description)
+                    if stored_procedure.description
+                    else None
+                ),
+                storedProcedureCode=StoredProcedureCode(
+                    language=stored_procedure.language, code=stored_procedure.definition
+                ),
+                databaseSchema=fqn.build(
+                    metadata=self.metadata,
+                    entity_type=DatabaseSchema,
+                    service_name=self.context.get().database_service,
+                    database_name=self.context.get().database,
+                    schema_name=self.context.get().database_schema,
+                ),
+                storedProcedureType=ROUTINE_TYPE_MAP[stored_procedure.procedure_type],
+            )
+            yield Either(right=stored_procedure_request)
+            self.register_record_stored_proc_request(stored_procedure_request)
+
+        except Exception as exc:
+            yield Either(
+                left=StackTraceError(
+                    name=stored_procedure.name,
+                    error=f"Error yielding Stored Procedure [{stored_procedure.name}] due to [{exc}]",
+                    stackTrace=traceback.format_exc(),
+                )
+            )

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

@@ -0,0 +1,36 @@
+#  Copyright 2025 Collate
+#  Licensed under the Collate Community License, Version 1.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  https://github.com/open-metadata/OpenMetadata/blob/main/ingestion/LICENSE
+#  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.
+"""
+MariaDB models
+"""
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from metadata.generated.schema.entity.data.storedProcedure import StoredProcedureType
+
+ROUTINE_TYPE_MAP = {
+    "PROCEDURE": StoredProcedureType.StoredProcedure,
+    "FUNCTION": StoredProcedureType.Function,
+}
+
+
+class MariaDBStoredProcedure(BaseModel):
+    """
+    MariaDB stored procedure list query results
+    """
+
+    name: str = Field(alias="procedure_name")
+    schema_name: str
+    definition: str
+    language: Optional[str]
+    procedure_type: Optional[str]
+    description: Optional[str]

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

@@ -0,0 +1,43 @@
+#  Copyright 2025 Collate
+#  Licensed under the Collate Community License, Version 1.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  https://github.com/open-metadata/OpenMetadata/blob/main/ingestion/LICENSE
+#  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.
+"""
+SQL Queries used during MariaDB ingestion
+"""
+
+MARIADB_GET_STORED_PROCEDURES = """
+SELECT
+    ROUTINE_NAME AS procedure_name,
+    ROUTINE_SCHEMA AS schema_name,
+    ROUTINE_DEFINITION AS definition,
+    ROUTINE_TYPE AS procedure_type,
+    ROUTINE_COMMENT AS description,
+    EXTERNAL_LANGUAGE AS language
+FROM
+    information_schema.ROUTINES
+WHERE
+    ROUTINE_SCHEMA = '{schema_name}'
+    AND ROUTINE_TYPE = 'PROCEDURE'
+"""
+
+MARIADB_GET_FUNCTIONS = """
+SELECT
+    ROUTINE_NAME AS procedure_name,
+    ROUTINE_SCHEMA AS schema_name,
+    ROUTINE_DEFINITION AS definition,
+    ROUTINE_TYPE AS procedure_type,
+    ROUTINE_COMMENT AS description,
+    EXTERNAL_LANGUAGE AS language
+FROM
+    information_schema.ROUTINES
+WHERE
+    ROUTINE_SCHEMA = '{schema_name}'
+    AND ROUTINE_TYPE = 'FUNCTION'
+"""

metadata/ingestion/source/database/oracle/connection.py

@@ -48,7 +48,9 @@ from metadata.ingestion.connections.test_connections import test_connection_db_c
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.database.oracle.queries import (
     CHECK_ACCESS_TO_ALL,
+    TEST_MATERIALIZED_VIEWS,
     TEST_ORACLE_GET_STORED_PACKAGES,
+    TEST_QUERY_HISTORY,
 )
 from metadata.utils.constants import THREE_MIN
 from metadata.utils.logger import ingestion_logger
@@ -99,6 +101,8 @@ class OracleConnection(BaseConnection[OracleConnectionConfig, Engine]):
         test_conn_queries = {
             "CheckAccess": CHECK_ACCESS_TO_ALL,
             "PackageAccess": TEST_ORACLE_GET_STORED_PACKAGES,
+            "GetMaterializedViews": TEST_MATERIALIZED_VIEWS,
+            "GetQueryHistory": TEST_QUERY_HISTORY,
         }
 
         return test_connection_db_common(

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

@@ -135,6 +135,24 @@ WHERE
 )
 
 CHECK_ACCESS_TO_ALL = "SELECT table_name FROM DBA_TABLES where ROWNUM < 2"
+
+
+TEST_MATERIALIZED_VIEWS = textwrap.dedent(
+    """
+SELECT COUNT(*) as count
+FROM DBA_MVIEWS
+WHERE ROWNUM = 1
+"""
+)
+
+TEST_QUERY_HISTORY = textwrap.dedent(
+    """
+SELECT COUNT(*) as count
+FROM gv$sql
+WHERE ROWNUM = 1
+"""
+)
+
 ORACLE_GET_STORED_PROCEDURE_QUERIES = textwrap.dedent(
     """
 WITH SP_HISTORY AS (SELECT

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

@@ -43,6 +43,9 @@ from metadata.ingestion.source.database.postgres.queries import (
     POSTGRES_GET_DATABASE,
     POSTGRES_TEST_GET_QUERIES,
     POSTGRES_TEST_GET_TAGS,
+    TEST_COLUMN_METADATA,
+    TEST_INFORMATION_SCHEMA_COLUMNS,
+    TEST_TABLE_COMMENTS,
 )
 from metadata.ingestion.source.database.postgres.utils import (
     get_postgres_time_column_name,
@@ -91,6 +94,9 @@ class PostgresConnection(BaseConnection[PostgresConnectionConfig, Engine]):
             ),
             "GetDatabases": POSTGRES_GET_DATABASE,
             "GetTags": POSTGRES_TEST_GET_TAGS,
+            "GetColumnMetadata": TEST_COLUMN_METADATA,
+            "GetTableComments": TEST_TABLE_COMMENTS,
+            "GetInformationSchemaColumns": TEST_INFORMATION_SCHEMA_COLUMNS,
         }
         return test_connection_db_common(
             metadata=metadata,

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

@@ -249,3 +249,25 @@ WHERE
     prokind = 'f'
     and pg_namespace.nspname = '{schema_name}';
 """
+
+TEST_COLUMN_METADATA = """
+SELECT COUNT(*) as count
+FROM pg_catalog.pg_attribute a
+LEFT JOIN pg_catalog.pg_description pgd ON (
+    pgd.objoid = a.attrelid AND pgd.objsubid = a.attnum)
+WHERE 1=0
+"""
+
+TEST_TABLE_COMMENTS = """
+SELECT COUNT(*) as count
+FROM pg_catalog.pg_class c
+LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+LEFT JOIN pg_catalog.pg_description pgd ON pgd.objsubid = 0 AND pgd.objoid = c.oid
+WHERE 1=0
+"""
+
+TEST_INFORMATION_SCHEMA_COLUMNS = """
+SELECT COUNT(*) as count
+FROM information_schema.columns
+WHERE 1=0
+"""