adding option for alter behavior

Author: benc-db

dbt/adapters/databricks/impl.py

@@ -1172,10 +1172,6 @@ def _describe_relation(
     ) -> RelationResults:
         results = {}
         kwargs = {"relation": relation}
-        # Metric views are stored as views in information_schema but have different properties
-        results["information_schema.views"] = get_first_row(
-            adapter.execute_macro("get_view_description", kwargs=kwargs)
-        )
         results["information_schema.tags"] = adapter.execute_macro("fetch_tags", kwargs=kwargs)
         results["show_tblproperties"] = adapter.execute_macro("fetch_tbl_properties", kwargs=kwargs)
         kwargs = {"table_name": relation}

dbt/adapters/databricks/relation.py

@@ -48,6 +48,15 @@ def render(self) -> str:
         """Return the type formatted for SQL statements (replace underscores with spaces)"""
         return self.value.replace("_", " ").upper()
 
+    def render_for_alter(self) -> str:
+        """Return the type formatted for ALTER statements.
+
+        Metric views use ALTER VIEW (not ALTER METRIC VIEW) syntax.
+        """
+        if self == DatabricksRelationType.MetricView:
+            return "VIEW"
+        return self.render()
+
 
 class DatabricksTableType(StrEnum):
     External = "external"

dbt/adapters/databricks/relation_configs/metric_view.py

@@ -1,52 +1,101 @@
-from typing import Optional
+from typing import ClassVar, Optional
 
-from typing_extensions import Self
+from dbt.adapters.contracts.relation import RelationConfig
+from dbt.adapters.relation_configs.config_base import RelationResults
+from dbt_common.exceptions import DbtRuntimeError
 
-from dbt.adapters.databricks.logging import logger
 from dbt.adapters.databricks.relation_configs.base import (
-    DatabricksRelationChangeSet,
+    DatabricksComponentConfig,
+    DatabricksComponentProcessor,
     DatabricksRelationConfigBase,
 )
-from dbt.adapters.databricks.relation_configs.column_comments import ColumnCommentsProcessor
-from dbt.adapters.databricks.relation_configs.column_tags import ColumnTagsProcessor
-from dbt.adapters.databricks.relation_configs.comment import CommentProcessor
-from dbt.adapters.databricks.relation_configs.query import QueryProcessor
 from dbt.adapters.databricks.relation_configs.tags import TagsProcessor
 from dbt.adapters.databricks.relation_configs.tblproperties import TblPropertiesProcessor
 
 
+class MetricViewQueryConfig(DatabricksComponentConfig):
+    """Component encapsulating the YAML definition of a metric view."""
+
+    query: str
+
+    def get_diff(self, other: "MetricViewQueryConfig") -> Optional["MetricViewQueryConfig"]:
+        # Normalize whitespace for comparison
+        self_normalized = " ".join(self.query.split())
+        other_normalized = " ".join(other.query.split())
+        if self_normalized != other_normalized:
+            return self
+        return None
+
+
+class MetricViewQueryProcessor(DatabricksComponentProcessor[MetricViewQueryConfig]):
+    """Processor for metric view YAML definitions.
+
+    Metric views store their YAML definitions in information_schema.views, but wrapped
+    in $$ delimiters. This processor extracts and compares the YAML content.
+    """
+
+    name: ClassVar[str] = "query"
+
+    @classmethod
+    def from_relation_results(cls, result: RelationResults) -> MetricViewQueryConfig:
+        from dbt.adapters.databricks.logging import logger
+
+        # Get the view text from DESCRIBE EXTENDED output
+        describe_extended = result.get("describe_extended")
+        if not describe_extended:
+            raise DbtRuntimeError(
+                f"Cannot find metric view description. Result keys: {list(result.keys())}"
+            )
+
+        # Find the "View Text" row in DESCRIBE EXTENDED output
+        view_definition = None
+        for row in describe_extended:
+            if row[0] == "View Text":
+                view_definition = row[1]
+                break
+
+        logger.debug(
+            f"MetricViewQueryProcessor: view_definition = "
+            f"{view_definition[:200] if view_definition else 'None'}"
+        )
+
+        if not view_definition:
+            raise DbtRuntimeError("Metric view has no 'View Text' in DESCRIBE EXTENDED output")
+
+        view_definition = view_definition.strip()
+
+        # Extract YAML content from $$ delimiters if present
+        # Format: $$ yaml_content $$
+        if "$$" in view_definition:
+            parts = view_definition.split("$$")
+            if len(parts) >= 2:
+                # The YAML is between the first and second $$ markers
+                view_definition = parts[1].strip()
+
+        return MetricViewQueryConfig(query=view_definition)
+
+    @classmethod
+    def from_relation_config(cls, relation_config: RelationConfig) -> MetricViewQueryConfig:
+        query = relation_config.compiled_code
+
+        if query:
+            return MetricViewQueryConfig(query=query.strip())
+        else:
+            raise DbtRuntimeError(
+                f"Cannot compile metric view {relation_config.identifier} with no YAML definition"
+            )
+
+
 class MetricViewConfig(DatabricksRelationConfigBase):
+    """Config for metric views.
+
+    Metric views use YAML definitions stored in information_schema.views wrapped in $$ delimiters.
+    Changes to the YAML definition can be applied via ALTER VIEW AS.
+    Tags and tblproperties can also be altered incrementally.
+    """
+
     config_components = [
         TagsProcessor,
         TblPropertiesProcessor,
-        QueryProcessor,
-        CommentProcessor,
-        ColumnCommentsProcessor,
-        ColumnTagsProcessor,
+        MetricViewQueryProcessor,
     ]
-
-    def get_changeset(self, existing: Self) -> Optional[DatabricksRelationChangeSet]:
-        changeset = super().get_changeset(existing)
-        if changeset:
-            # Metric views: query changes require full refresh (can't ALTER YAML definition)
-            if "query" in changeset.changes:
-                logger.debug(
-                    "Metric view YAML definition changed, requiring replace, as there is"
-                    " no API to update the YAML specification via ALTER."
-                )
-                changeset.requires_full_refresh = True
-            # Comment changes also require full refresh for metric views
-            if "comment" in changeset.changes:
-                logger.debug(
-                    "Metric view description changed, requiring replace, as there is"
-                    " no API yet to update comments."
-                )
-                changeset.requires_full_refresh = True
-            # Column comment changes require full refresh for metric views
-            if "column_comments" in changeset.changes:
-                logger.debug(
-                    "Metric view column comments changed, requiring replace, as there is"
-                    " no API to update column comments for metric views."
-                )
-                changeset.requires_full_refresh = True
-        return changeset

dbt/include/databricks/macros/materializations/metric_view.sql

@@ -8,9 +8,24 @@
   {{ run_pre_hooks() }}
 
   {% if existing_relation %}
-    {#- Metric views always use CREATE OR REPLACE - no alter path for now -#}
-    {{ log('Using replace_with_metric_view (metric views always use replace)') }}
-    {{ replace_with_metric_view(existing_relation, target_relation) }}
+    {#- Only use alter path if existing relation is actually a metric_view -#}
+    {% if existing_relation.is_metric_view and relation_should_be_altered(existing_relation) %}
+      {% set configuration_changes = get_metric_view_configuration_changes(existing_relation) %}
+      {% if configuration_changes and configuration_changes.changes %}
+        {% if configuration_changes.requires_full_refresh %}
+          {{ replace_with_metric_view(existing_relation, target_relation) }}
+        {% else %}
+          {{ alter_metric_view(target_relation, configuration_changes.changes) }}
+        {% endif %}
+      {% else %}
+        {# No changes detected - run a no-op statement for dbt tracking #}
+        {% call statement('main') %}
+          select 1
+        {% endcall %}
+      {% endif %}
+    {% else %}
+      {{ replace_with_metric_view(existing_relation, target_relation) }}
+    {% endif %}
   {% else %}
     {% call statement('main') -%}
       {{ get_create_metric_view_as_sql(target_relation, sql) }}
@@ -28,4 +43,4 @@
   {{ run_post_hooks() }}
 
   {{ return({'relations': [target_relation]}) }}
-{%- endmaterialization %}
+{%- endmaterialization %}

dbt/include/databricks/macros/relations/components/query.sql

@@ -8,7 +8,7 @@
 {% endmacro %}
 
 {% macro get_alter_query_sql(target_relation, query) -%}
-  ALTER {{ target_relation.type.render() }} {{ target_relation.render() }} AS (
+  ALTER {{ target_relation.type.render_for_alter() }} {{ target_relation.render() }} AS (
     {{ query }}
   )
-{%- endmacro %}
+{%- endmacro %}

dbt/include/databricks/macros/relations/config.sql

@@ -5,11 +5,9 @@
     {% do return(configuration_changes) %}
 {%- endmacro -%}
 
-{#- Metric view specific config changes - needed because metric views are stored as VIEWs in DB -#}
 {%- macro get_metric_view_configuration_changes(existing_relation) -%}
-    {#- existing_relation should already be typed as metric_view via incorporate() -#}
     {%- set existing_config = adapter.get_relation_config(existing_relation) -%}
     {%- set model_config = adapter.get_config_from_model(config.model) -%}
     {%- set configuration_changes = model_config.get_changeset(existing_config) -%}
     {% do return(configuration_changes) %}
-{%- endmacro -%}
+{%- endmacro -%}

dbt/include/databricks/macros/relations/metric_view/alter.sql

@@ -7,30 +7,50 @@
   {% set tags = changes.get("tags") %}
   {% set tblproperties = changes.get("tblproperties") %}
   {% set query = changes.get("query") %}
-  {% set column_comments = changes.get("column_comments") %}
 
-  {# For metric views, only tags and tblproperties can be altered without recreating #}
+  {# Handle YAML definition changes via ALTER VIEW AS #}
+  {% if query %}
+    {% call statement('main') %}
+      {{ get_alter_metric_view_as_sql(target_relation, query.query) }}
+    {% endcall %}
+  {% else %}
+    {# Ensure statement('main') is called for dbt to track the run #}
+    {% call statement('main') %}
+      select 1
+    {% endcall %}
+  {% endif %}
+
   {% if tags %}
     {{ apply_tags(target_relation, tags.set_tags) }}
   {% endif %}
   {% if tblproperties %}
     {{ apply_tblproperties(target_relation, tblproperties.tblproperties) }}
   {% endif %}
+{% endmacro %}
 
-  {# Query changes and column comment changes require full refresh for metric views #}
-  {% if query or column_comments %}
-    {{ exceptions.warn("Metric view YAML definition or column comment changes detected that cannot be applied via ALTER. These changes will require CREATE OR REPLACE on next run.") }}
-  {% endif %}
+{% macro get_alter_metric_view_as_sql(relation, yaml_content) -%}
+  {{ adapter.dispatch('get_alter_metric_view_as_sql', 'dbt')(relation, yaml_content) }}
+{%- endmacro %}
+
+{% macro databricks__get_alter_metric_view_as_sql(relation, yaml_content) %}
+alter view {{ relation.render() }} as $$
+{{ yaml_content }}
+$$
 {% endmacro %}
 
 {% macro replace_with_metric_view(existing_relation, target_relation) %}
   {% set sql = adapter.clean_sql(sql) %}
   {% set tags = config.get('databricks_tags') %}
+  {% set tblproperties = config.get('tblproperties') %}
   {{ execute_multiple_statements(get_replace_sql(existing_relation, target_relation, sql)) }}
   {%- do apply_tags(target_relation, tags) -%}
 
+  {% if tblproperties %}
+    {{ apply_tblproperties(target_relation, tblproperties) }}
+  {% endif %}
+
   {% set column_tags = adapter.get_column_tags_from_model(config.model) %}
   {% if column_tags and column_tags.set_column_tags %}
     {{ apply_column_tags(target_relation, column_tags) }}
   {% endif %}
-{% endmacro %}
+{% endmacro %}

dbt/include/databricks/macros/relations/tags.sql

@@ -29,12 +29,7 @@
 {%- endmacro -%}
 
 {% macro alter_set_tags(relation, tags) -%}
-  {#- Metric views use ALTER VIEW syntax, not ALTER METRIC VIEW -#}
-  {%- if relation.is_metric_view -%}
-  ALTER VIEW {{ relation.render() }} SET TAGS (
-  {%- else -%}
-  ALTER {{ relation.type.render() }} {{ relation.render() }} SET TAGS (
-  {%- endif -%}
+  ALTER {{ relation.type.render_for_alter() }} {{ relation.render() }} SET TAGS (
     {% for tag in tags -%}
       '{{ tag }}' = '{{ tags[tag] }}' {%- if not loop.last %}, {% endif -%}
     {%- endfor %}

dbt/include/databricks/macros/relations/tblproperties.sql

@@ -21,7 +21,7 @@
   {% set tblproperty_statment = databricks__tblproperties_clause(tblproperties) %}
   {% if tblproperty_statment %}
     {%- call statement('main') -%}
-      ALTER {{ relation.type.render() }} {{ relation.render() }} SET {{ tblproperty_statment}}
+      ALTER {{ relation.type.render_for_alter() }} {{ relation.render() }} SET {{ tblproperty_statment}}
     {%- endcall -%}
   {% endif %}
 {%- endmacro -%}