Implement get_catalog_for_single_relation macro

.changes/unreleased/Fixes-20240516-224134.yaml

@@ -0,0 +1,6 @@
+kind: Fixes
+body: Implement get_relation_metadata macro
+time: 2024-05-16T22:41:34.256095+01:00
+custom:
+    Author: aranke
+    Issue: "1048"

.gitignore

@@ -94,3 +94,4 @@ venv/
 
 # vscode
 .vscode/
+.venv/

dbt/adapters/snowflake/impl.py

@@ -2,7 +2,7 @@
 from typing import Mapping, Any, Optional, List, Union, Dict, FrozenSet, Tuple
 
 import agate
-
+from dbt.adapters.base import BaseRelation
 from dbt.adapters.base.impl import AdapterConfig, ConstraintSupport
 from dbt.adapters.base.meta import available
 from dbt.adapters.capability import CapabilityDict, CapabilitySupport, Support, Capability
@@ -11,14 +11,23 @@
     LIST_SCHEMAS_MACRO_NAME,
     LIST_RELATIONS_MACRO_NAME,
 )
-
-from dbt.adapters.snowflake import SnowflakeConnectionManager
-from dbt.adapters.snowflake import SnowflakeRelation
-from dbt.adapters.snowflake import SnowflakeColumn
 from dbt_common.contracts.constraints import ConstraintType
+from dbt_common.contracts.metadata import (
+    TableMetadata,
+    StatsDict,
+    StatsItem,
+    CatalogTable,
+    ColumnMetadata,
+)
 from dbt_common.exceptions import CompilationError, DbtDatabaseError, DbtRuntimeError
 from dbt_common.utils import filter_null_values
 
+from dbt.adapters.snowflake import SnowflakeColumn
+from dbt.adapters.snowflake import SnowflakeConnectionManager
+from dbt.adapters.snowflake import SnowflakeRelation
+
+SHOW_OBJECT_METADATA_MACRO_NAME = "snowflake__show_object_metadata"
+
 
 @dataclass
 class SnowflakeConfig(AdapterConfig):
@@ -54,6 +63,7 @@ class SnowflakeAdapter(SQLAdapter):
             Capability.SchemaMetadataByRelations: CapabilitySupport(support=Support.Full),
             Capability.TableLastModifiedMetadata: CapabilitySupport(support=Support.Full),
             Capability.TableLastModifiedMetadataBatch: CapabilitySupport(support=Support.Full),
+            Capability.GetCatalogForSingleRelation: CapabilitySupport(support=Support.Full),
         }
     )
 
@@ -129,6 +139,83 @@ def get_columns_in_relation(self, relation):
             else:
                 raise
 
+    def _show_object_metadata(self, relation):
+        try:
+            kwargs = {"relation": relation}
+            results = self.execute_macro(SHOW_OBJECT_METADATA_MACRO_NAME, kwargs=kwargs)
+        except DbtDatabaseError as exc:
+            # If we don't have permissions to the object, return empty
+            if "Object does not exist" in str(exc):
+                return None
+        else:
+            # If we don't get any results, return empty
+            if len(results) == 0:
+                return None
+
+            return results
+
+    def get_catalog_for_single_relation(self, relation: BaseRelation) -> Optional[CatalogTable]:
+        object_metadata = self._show_object_metadata(relation)
+
+        if object_metadata:
+            row = object_metadata[0]
+
+            is_dynamic = row.get("is_dynamic")
+            kind = row.get("kind")
+
+            if is_dynamic == "YES" and kind == "BASE TABLE":
+                table_type = "DYNAMIC TABLE"
+            else:
+                table_type = kind
+
+            table_metadata = TableMetadata(
+                type=table_type,
+                schema=row.get("schema_name"),
+                name=row.get("name"),
+                database=row.get("database_name"),
+                comment=row.get("comment"),
+                owner=row.get("owner"),
+            )
+
+            stats_dict: StatsDict = {
+                "has_stats": StatsItem(
+                    id="has_stats",
+                    label="Has Stats?",
+                    value=True,
+                    include=False,
+                    description="Indicates whether there are statistics for this table",
+                ),
+                "row_count": StatsItem(
+                    id="row_count",
+                    label="Row Count",
+                    value=row.get("rows"),
+                    include=True,
+                    description="Number of rows in the table as reported by Snowflake",
+                ),
+                "bytes": StatsItem(
+                    id="bytes",
+                    label="Approximate Size",
+                    value=row.get("bytes"),
+                    include=True,
+                    description="Size of the table as reported by Snowflake",
+                ),
+            }
+
+            catalog_columns = {}
+            columns_metadata = self.get_columns_in_relation(relation)
+
+            for i, c in enumerate(columns_metadata):
+                name = c.column
+                catalog_columns[name] = ColumnMetadata(type=c.dtype, index=i + 1, name=name)
+
+            return CatalogTable(
+                metadata=table_metadata,
+                columns=catalog_columns,
+                stats=stats_dict,
+            )
+        else:
+            return None
+
     def list_relations_without_caching(
         self, schema_relation: SnowflakeRelation
     ) -> List[SnowflakeRelation]:

dbt/include/snowflake/macros/adapters.sql

@@ -47,6 +47,15 @@
   {% do return(columns) %}
 {% endmacro %}
 
+{% macro snowflake__show_object_metadata(relation) %}
+  {%- set sql -%}
+    show objects like '{{ relation.identifier }}' in {{ relation.database }}.{{ relation.schema }} limit 1
+  {%- endset -%}
+
+  {%- set result = run_query(sql) -%}
+  {{ return(result) }}
+{% endmacro %}
+
 {% macro snowflake__list_schemas(database) -%}
   {# 10k limit from here: https://docs.snowflake.net/manuals/sql-reference/sql/show-schemas.html#usage-notes #}
   {% set maximum = 10000 %}

dev-requirements.txt

@@ -1,8 +1,8 @@
 # install latest changes in dbt-core
 git+https://github.com/dbt-labs/dbt-core.git#egg=dbt-core&subdirectory=core
-git+https://github.com/dbt-labs/dbt-adapters.git
-git+https://github.com/dbt-labs/dbt-adapters.git#subdirectory=dbt-tests-adapter
-git+https://github.com/dbt-labs/dbt-common.git
+git+https://github.com/dbt-labs/dbt-adapters.git@get_relation_metadata
+git+https://github.com/dbt-labs/dbt-adapters.git@get_relation_metadata#subdirectory=dbt-tests-adapter
+git+https://github.com/dbt-labs/dbt-common.git@main
 
 # dev
 ipdb~=0.13.13

setup.py

@@ -57,8 +57,8 @@ def _plugin_version() -> str:
     packages=find_namespace_packages(include=["dbt", "dbt.*"]),
     include_package_data=True,
     install_requires=[
-        "dbt-common>=1.0.4,<2.0",
-        "dbt-adapters>=1.1.1,<2.0",
+        # "dbt-common>=1.2.0,<2.0",
+        "dbt-adapters @ git+https://github.com/dbt-labs/dbt-adapters.git@get_relation_metadata",
         "snowflake-connector-python[secure-local-storage]~=3.0",
         # add dbt-core to ensure backwards compatibility of installation, this is not a functional dependency
         "dbt-core>=1.8.0",

tests/functional/adapter/test_basic.py

@@ -5,6 +5,9 @@
 from dbt.tests.adapter.basic.test_singular_tests_ephemeral import (
     BaseSingularTestsEphemeral,
 )
+from dbt.tests.adapter.basic.test_get_catalog_for_single_relation import (
+    BaseGetCatalogForSingleRelation,
+)
 from dbt.tests.adapter.basic.test_empty import BaseEmpty
 from dbt.tests.adapter.basic.test_ephemeral import BaseEphemeral
 from dbt.tests.adapter.basic.test_incremental import BaseIncremental
@@ -25,6 +28,10 @@ class TestSingularTestsSnowflake(BaseSingularTests):
     pass
 
 
+class TestGetCatalogForSingleRelationSnowflake(BaseGetCatalogForSingleRelation):
+    pass
+
+
 class TestSingularTestsEphemeralSnowflake(BaseSingularTestsEphemeral):
     pass
 

tests/unit/mock_adapter.py

@@ -1,7 +1,7 @@
+from contextlib import contextmanager
 from unittest import mock
 
 from dbt.adapters.base import BaseAdapter
-from contextlib import contextmanager
 
 
 def adapter_factory():
@@ -33,6 +33,9 @@ def rename_relation(self, *args, **kwargs):
         def get_columns_in_relation(self, *args, **kwargs):
             return self.responder.get_columns_in_relation(*args, **kwargs)
 
+        def get_catalog_for_single_relation(self, *args, **kwargs):
+            return self.responder.get_catalog_for_single_relation(*args, **kwargs)
+
         def expand_column_types(self, *args, **kwargs):
             return self.responder.expand_column_types(*args, **kwargs)