openmetadata-ingestion 1.6.9.0__py3-none-any.whl → 1.7.0.0__py3-none-any.whl

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

@@ -0,0 +1,138 @@
+#  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.
+
+"""
+Source connection handler
+"""
+from functools import partial
+from typing import Optional
+
+from cassandra.auth import PlainTextAuthProvider
+from cassandra.cluster import (
+    EXEC_PROFILE_DEFAULT,
+    Cluster,
+    ExecutionProfile,
+    ProtocolVersion,
+)
+from cassandra.cluster import Session as CassandraSession
+from pydantic import BaseModel
+
+from metadata.generated.schema.entity.automations.workflow import (
+    Workflow as AutomationWorkflow,
+)
+from metadata.generated.schema.entity.services.connections.database.cassandraConnection import (
+    CassandraConnection,
+)
+from metadata.generated.schema.entity.services.connections.testConnectionResult import (
+    TestConnectionResult,
+)
+from metadata.ingestion.connections.builders import init_empty_connection_arguments
+from metadata.ingestion.connections.test_connections import test_connection_steps
+from metadata.ingestion.ometa.ometa_api import OpenMetadata
+from metadata.ingestion.source.database.cassandra.queries import (
+    CASSANDRA_GET_KEYSPACE_MATERIALIZED_VIEWS,
+    CASSANDRA_GET_KEYSPACE_TABLES,
+    CASSANDRA_GET_KEYSPACES,
+    CASSANDRA_GET_RELEASE_VERSION,
+)
+from metadata.utils.constants import THREE_MIN
+
+
+def get_connection(connection: CassandraConnection):
+    """
+    Create connection
+    """
+
+    cluster_config = {}
+    if hasattr(connection.authType, "cloudConfig"):
+        cloud_config = connection.authType.cloudConfig
+        cluster_cloud_config = {
+            "connect_timeout": cloud_config.connectTimeout,
+            "use_default_tempdir": True,
+            "secure_connect_bundle": cloud_config.secureConnectBundle,
+        }
+        profile = ExecutionProfile(request_timeout=cloud_config.requestTimeout)
+        auth_provider = PlainTextAuthProvider("token", cloud_config.token)
+        cluster_config.update(
+            {
+                "cloud": cluster_cloud_config,
+                "auth_provider": auth_provider,
+                "execution_profiles": {EXEC_PROFILE_DEFAULT: profile},
+                "protocol_version": ProtocolVersion.V4,
+            }
+        )
+    else:
+        host, port = connection.hostPort.split(":")
+        cluster_config.update({"contact_points": [host], "port": port})
+        if connection.username and getattr(connection.authType, "password", None):
+            cluster_config["auth_provider"] = PlainTextAuthProvider(
+                username=connection.username,
+                password=connection.authType.password.get_secret_value(),
+            )
+
+    connection.connectionArguments = (
+        connection.connectionArguments or init_empty_connection_arguments()
+    )
+
+    cluster = Cluster(
+        **cluster_config,
+        ssl_context=connection.connectionArguments.root.get("ssl_context"),
+    )
+    session = cluster.connect()
+
+    return session
+
+
+def test_connection(
+    metadata: OpenMetadata,
+    session: CassandraSession,
+    service_connection: CassandraConnection,
+    automation_workflow: Optional[AutomationWorkflow] = None,
+    timeout_seconds: Optional[int] = THREE_MIN,
+) -> TestConnectionResult:
+    """
+    Test connection. This can be executed either as part
+    of a metadata workflow or during an Automation Workflow
+    """
+
+    class SchemaHolder(BaseModel):
+        schema: Optional[str] = None
+
+    holder = SchemaHolder()
+
+    def test_get_release_version(session: CassandraConnection):
+        session.execute(CASSANDRA_GET_RELEASE_VERSION)
+
+    def test_get_schemas(session: CassandraSession, holder_: SchemaHolder):
+        for keyspace in session.execute(CASSANDRA_GET_KEYSPACES):
+            holder_.schema = keyspace.keyspace_name
+            break
+
+    def test_get_tables(session: CassandraSession, holder_: SchemaHolder):
+        session.execute(CASSANDRA_GET_KEYSPACE_TABLES, [holder_.schema])
+
+    def test_get_views(session: CassandraSession, holder_: SchemaHolder):
+        session.execute(CASSANDRA_GET_KEYSPACE_MATERIALIZED_VIEWS, [holder_.schema])
+
+    test_fn = {
+        "CheckAccess": partial(test_get_release_version, session),
+        "GetSchemas": partial(test_get_schemas, session, holder),
+        "GetTables": partial(test_get_tables, session, holder),
+        "GetViews": partial(test_get_views, session, holder),
+    }
+
+    return test_connection_steps(
+        metadata=metadata,
+        test_fn=test_fn,
+        service_type=service_connection.type.value,
+        automation_workflow=automation_workflow,
+        timeout_seconds=timeout_seconds,
+    )

metadata/ingestion/source/database/cassandra/helpers.py

@@ -0,0 +1,100 @@
+#  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.
+"""
+Cassandra source helpers.
+"""
+from __future__ import annotations
+
+from metadata.generated.schema.entity.data.table import Column, DataType
+
+
+class CassandraColumnParser:
+    """
+    Responsible for containing the logic to parse a column from Cassandra to OpenMetadata
+    """
+
+    datatype_mapping = {
+        "ascii": DataType.STRING,
+        "bigint": DataType.BIGINT,
+        "blob": DataType.BLOB,
+        "boolean": DataType.BOOLEAN,
+        "date": DataType.DATE,
+        "decimal": DataType.DECIMAL,
+        "double": DataType.DOUBLE,
+        "duration": DataType.INTERVAL,
+        "float": DataType.FLOAT,
+        "uuid": DataType.UUID,
+        "inet": DataType.INET,
+        "int": DataType.INT,
+        "list": DataType.ARRAY,
+        "map": DataType.MAP,
+        "set": DataType.SET,
+        "smallint": DataType.SMALLINT,
+        "text": DataType.TEXT,
+        "time": DataType.TIME,
+        "timestamp": DataType.TIMESTAMP,
+        "timeuuid": DataType.UUID,
+        "tinyint": DataType.TINYINT,
+        "tuple": DataType.TUPLE,
+        "varint": DataType.STRING,
+        "struct": DataType.STRUCT,
+    }
+
+    @classmethod
+    def parse(cls, field) -> Column:
+        """
+        Parses a Cassandra table column into an OpenMetadata column.
+        """
+
+        data_type = None
+        array_data_type = None
+        raw_data_type = ""
+
+        for letter in field.type:
+            if letter == "<":
+                if raw_data_type in ("", "frozen"):
+                    raw_data_type = ""
+                    continue
+
+                if not data_type:
+                    data_type = cls.datatype_mapping.get(
+                        raw_data_type.lower(), DataType.UNKNOWN
+                    )
+                elif not array_data_type:
+                    array_data_type = cls.datatype_mapping.get(
+                        raw_data_type.lower(), DataType.UNKNOWN
+                    )
+
+                raw_data_type = ""
+                if data_type != DataType.ARRAY or array_data_type:
+                    break
+
+            elif letter == ">":
+                if not array_data_type and data_type:
+                    array_data_type = cls.datatype_mapping.get(
+                        raw_data_type.lower(), DataType.UNKNOWN
+                    )
+                    break
+
+            else:
+                raw_data_type += letter
+
+        if not data_type:
+            data_type = cls.datatype_mapping.get(field.type.lower(), DataType.UNKNOWN)
+
+        column_def = {
+            "name": field.column_name,
+            "dataTypeDisplay": field.type,
+            "dataType": data_type,
+            "arrayDataType": array_data_type,
+        }
+
+        return Column(**column_def)

metadata/ingestion/source/database/cassandra/metadata.py

@@ -0,0 +1,138 @@
+#  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.
+"""
+Cassandra source methods.
+"""
+
+import traceback
+from typing import Iterable, List, Optional
+
+from metadata.generated.schema.entity.data.table import Column, TableType
+from metadata.generated.schema.entity.services.connections.database.cassandraConnection import (
+    CassandraConnection,
+)
+from metadata.generated.schema.metadataIngestion.workflow import (
+    Source as WorkflowSource,
+)
+from metadata.ingestion.api.steps import InvalidSourceException
+from metadata.ingestion.ometa.ometa_api import OpenMetadata
+from metadata.ingestion.source.database.cassandra.helpers import CassandraColumnParser
+from metadata.ingestion.source.database.cassandra.queries import (
+    CASSANDRA_GET_KEYSPACE_MATERIALIZED_VIEWS,
+    CASSANDRA_GET_KEYSPACE_TABLES,
+    CASSANDRA_GET_KEYSPACES,
+    CASSANDRA_GET_TABLE_COLUMNS,
+)
+from metadata.ingestion.source.database.common_nosql_source import (
+    CommonNoSQLSource,
+    TableNameAndType,
+)
+from metadata.utils.logger import ingestion_logger
+
+logger = ingestion_logger()
+
+
+class CassandraSource(CommonNoSQLSource):
+    """
+    Implements the necessary methods to extract
+    Database metadata from Dynamo Source
+    """
+
+    def __init__(self, config: WorkflowSource, metadata: OpenMetadata):
+        super().__init__(config, metadata)
+        self.cassandra = self.connection_obj
+
+    @classmethod
+    def create(
+        cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
+    ):
+        config: WorkflowSource = WorkflowSource.model_validate(config_dict)
+        connection: CassandraConnection = config.serviceConnection.root.config
+        if not isinstance(connection, CassandraConnection):
+            raise InvalidSourceException(
+                f"Expected CassandraConnection, but got {connection}"
+            )
+        return cls(config, metadata)
+
+    def get_schema_name_list(self) -> List[str]:
+        """
+        Method to get list of schema names available within NoSQL db
+        need to be overridden by sources
+        """
+        schema_names = []
+        try:
+            schema_names = [
+                row.keyspace_name
+                for row in self.cassandra.execute(CASSANDRA_GET_KEYSPACES)
+            ]
+        except Exception as exp:
+            logger.debug(f"Failed to list keyspace names: {exp}")
+            logger.debug(traceback.format_exc())
+
+        return schema_names
+
+    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
+        """
+        tables = []
+        try:
+            tables = [
+                TableNameAndType(name=row.table_name)
+                for row in self.cassandra.execute(
+                    CASSANDRA_GET_KEYSPACE_TABLES, [schema_name]
+                )
+            ]
+        except Exception as exp:
+            logger.debug(
+                f"Failed to list table names for schema [{schema_name}]: {exp}"
+            )
+            logger.debug(traceback.format_exc())
+
+        return tables
+
+    def query_view_names_and_types(
+        self, schema_name: str
+    ) -> Iterable[TableNameAndType]:
+        """
+        Method to get list of materialized view names available within schema db
+        need to be overridden by sources
+        """
+        materialized_views = []
+        try:
+            materialized_views = [
+                TableNameAndType(name=row.view_name, type_=TableType.MaterializedView)
+                for row in self.cassandra.execute(
+                    CASSANDRA_GET_KEYSPACE_MATERIALIZED_VIEWS, [schema_name]
+                )
+            ]
+        except Exception as exp:
+            logger.debug(
+                f"Failed to list materialized view names for schema [{schema_name}]: {exp}"
+            )
+            logger.debug(traceback.format_exc())
+
+        return materialized_views
+
+    def get_table_columns(self, schema_name: str, table_name: str) -> List[Column]:
+        try:
+            data = self.cassandra.execute(
+                CASSANDRA_GET_TABLE_COLUMNS, [schema_name, table_name]
+            )
+            return [CassandraColumnParser.parse(field=field) for field in data]
+        except Exception as opf:
+            logger.debug(f"Failed to read table [{table_name}]: {opf}")
+            logger.debug(traceback.format_exc())
+
+        return []

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

@@ -0,0 +1,45 @@
+#  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 ingestion
+"""
+
+import textwrap
+
+CASSANDRA_GET_RELEASE_VERSION = textwrap.dedent(
+    """
+    SELECT release_version FROM system.local;
+    """
+)
+
+CASSANDRA_GET_KEYSPACES = textwrap.dedent(
+    """
+    SELECT * FROM system_schema.keyspaces
+    """
+)
+
+CASSANDRA_GET_KEYSPACE_TABLES = textwrap.dedent(
+    """
+    SELECT * FROM system_schema.tables WHERE keyspace_name = %s
+    """
+)
+
+CASSANDRA_GET_KEYSPACE_MATERIALIZED_VIEWS = textwrap.dedent(
+    """
+    SELECT * FROM system_schema.views WHERE keyspace_name = %s
+    """
+)
+
+CASSANDRA_GET_TABLE_COLUMNS = textwrap.dedent(
+    """
+    SELECT * FROM system_schema.columns WHERE keyspace_name = %s AND table_name = %s
+    """
+)

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

@@ -0,0 +1,10 @@
+from metadata.ingestion.source.database.cassandra.metadata import CassandraSource
+from metadata.profiler.interface.nosql.profiler_interface import NoSQLProfilerInterface
+from metadata.sampler.nosql.sampler import NoSQLSampler
+from metadata.utils.service_spec.default import DefaultDatabaseSpec
+
+ServiceSpec = DefaultDatabaseSpec(
+    metadata_source_class=CassandraSource,
+    profiler_class=NoSQLProfilerInterface,
+    sampler_class=NoSQLSampler,
+)

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

@@ -1,8 +1,8 @@
-#  Copyright 2021 Collate
-#  Licensed under the Apache License, Version 2.0 (the "License");
+#  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
-#  http://www.apache.org/licenses/LICENSE-2.0
+#  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.

metadata/ingestion/source/database/clickhouse/lineage.py

@@ -1,8 +1,8 @@
-#  Copyright 2021 Collate
-#  Licensed under the Apache License, Version 2.0 (the "License");
+#  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
-#  http://www.apache.org/licenses/LICENSE-2.0
+#  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.

metadata/ingestion/source/database/clickhouse/metadata.py

@@ -1,8 +1,8 @@
-#  Copyright 2021 Collate
-#  Licensed under the Apache License, Version 2.0 (the "License");
+#  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
-#  http://www.apache.org/licenses/LICENSE-2.0
+#  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.
@@ -10,7 +10,6 @@
 #  limitations under the License.
 """Clickhouse source module"""
 
-import traceback
 from typing import Iterable, Optional
 
 from clickhouse_sqlalchemy.drivers.base import ClickHouseDialect
@@ -145,35 +144,3 @@ class ClickhouseSource(CommonDbSourceService):
         ]
 
         return regular_tables + material_tables + view_tables
-
-    def get_schema_definition(
-        self, table_type: str, table_name: str, schema_name: str, inspector: Inspector
-    ) -> Optional[str]:
-        """
-        Get the DDL statement or View Definition for a table
-        """
-        try:
-            if table_type in {TableType.View, TableType.MaterializedView}:
-                definition_fn = inspector.get_view_definition
-                schema_definition = definition_fn(table_name, schema_name)
-                return (
-                    str(schema_definition).strip()
-                    if schema_definition is not None
-                    else None
-                )
-            schema_definition = inspector.get_table_ddl(
-                self.connection, table_name, schema_name
-            )
-            return (
-                str(schema_definition).strip()
-                if schema_definition is not None
-                else None
-            )
-
-        except NotImplementedError:
-            logger.warning("Schema definition not implemented")
-
-        except Exception as exc:
-            logger.debug(traceback.format_exc())
-            logger.warning(f"Failed to fetch schema definition for {table_name}: {exc}")
-        return None

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

@@ -1,8 +1,8 @@
-#  Copyright 2021 Collate
-#  Licensed under the Apache License, Version 2.0 (the "License");
+#  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
-#  http://www.apache.org/licenses/LICENSE-2.0
+#  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.

metadata/ingestion/source/database/clickhouse/query_parser.py

@@ -1,8 +1,8 @@
-#  Copyright 2021 Collate
-#  Licensed under the Apache License, Version 2.0 (the "License");
+#  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
-#  http://www.apache.org/licenses/LICENSE-2.0
+#  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.

metadata/ingestion/source/database/clickhouse/usage.py

@@ -1,8 +1,8 @@
-#  Copyright 2021 Collate
-#  Licensed under the Apache License, Version 2.0 (the "License");
+#  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
-#  http://www.apache.org/licenses/LICENSE-2.0
+#  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.

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

@@ -1,8 +1,8 @@
-#  Copyright 2021 Collate
-#  Licensed under the Apache License, Version 2.0 (the "License");
+#  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
-#  http://www.apache.org/licenses/LICENSE-2.0
+#  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.

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

@@ -0,0 +1,71 @@
+#  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.
+
+"""
+Source connection handler
+"""
+from typing import Optional
+
+from sqlalchemy.engine import Engine
+
+from metadata.generated.schema.entity.automations.workflow import (
+    Workflow as AutomationWorkflow,
+)
+from metadata.generated.schema.entity.services.connections.database.cockroachConnection import (
+    CockroachConnection,
+)
+from metadata.generated.schema.entity.services.connections.testConnectionResult import (
+    TestConnectionResult,
+)
+from metadata.ingestion.connections.builders import (
+    create_generic_db_connection,
+    get_connection_args_common,
+    get_connection_url_common,
+)
+from metadata.ingestion.connections.test_connections import test_connection_db_common
+from metadata.ingestion.ometa.ometa_api import OpenMetadata
+from metadata.ingestion.source.database.cockroach.queries import COCKROACH_GET_DATABASE
+from metadata.utils.constants import THREE_MIN
+
+
+def get_connection(connection: CockroachConnection) -> Engine:
+    """
+    Create connection
+    """
+    return create_generic_db_connection(
+        connection=connection,
+        get_connection_url_fn=get_connection_url_common,
+        get_connection_args_fn=get_connection_args_common,
+    )
+
+
+def test_connection(
+    metadata: OpenMetadata,
+    engine: Engine,
+    service_connection: CockroachConnection,
+    automation_workflow: Optional[AutomationWorkflow] = None,
+    timeout_seconds: Optional[int] = THREE_MIN,
+) -> TestConnectionResult:
+    """
+    Test connection. This can be executed either as part
+    of a metadata workflow or during an Automation Workflow
+    """
+    queries = {
+        "GetDatabases": COCKROACH_GET_DATABASE,
+    }
+    return test_connection_db_common(
+        metadata=metadata,
+        engine=engine,
+        service_connection=service_connection,
+        automation_workflow=automation_workflow,
+        queries=queries,
+        timeout_seconds=timeout_seconds,
+    )