diff --git a/CHANGELOG.md b/CHANGELOG.md
index 50c582ead..75c131913 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,10 +1,16 @@
+## dbt-databricks 1.12.0 (TBD)
+
+- Add support for metric views as a materialization ([1285](https://github.com/databricks/dbt-databricks/pull/1285))
+
 ## dbt-databricks 1.11.4 (TBD)
 
 ### Features
+
 - Add `query_id` to `SQLQueryStatus` events to improve query tracing and debugging
 
 ### Fixes
-- Fix `hard_deletes: invalidate` incorrectly invalidating active records in snapshots (thanks @Zurbste!) ([#1281](https://github.com/databricks/dbt-databricks/issues/1281)) 
+
+- Fix `hard_deletes: invalidate` incorrectly invalidating active records in snapshots (thanks @Zurbste!) ([#1281](https://github.com/databricks/dbt-databricks/issues/1281))
 
 ## dbt-databricks 1.11.3 (Dec 5, 2025)
 
diff --git a/dbt/adapters/databricks/impl.py b/dbt/adapters/databricks/impl.py
index 2190e1f9c..e33900c3a 100644
--- a/dbt/adapters/databricks/impl.py
+++ b/dbt/adapters/databricks/impl.py
@@ -76,6 +76,7 @@
 from dbt.adapters.databricks.relation_configs.materialized_view import (
     MaterializedViewConfig,
 )
+from dbt.adapters.databricks.relation_configs.metric_view import MetricViewConfig
 from dbt.adapters.databricks.relation_configs.streaming_table import (
     StreamingTableConfig,
 )
@@ -919,6 +920,8 @@ def get_relation_config(self, relation: DatabricksRelation) -> DatabricksRelatio
             return IncrementalTableAPI.get_from_relation(self, relation)
         elif relation.type == DatabricksRelationType.View:
             return ViewAPI.get_from_relation(self, relation)
+        elif relation.type == DatabricksRelationType.MetricView:
+            return MetricViewAPI.get_from_relation(self, relation)
         else:
             raise NotImplementedError(f"Relation type {relation.type} is not supported.")
 
@@ -934,6 +937,8 @@ def get_config_from_model(self, model: RelationConfig) -> DatabricksRelationConf
             return IncrementalTableAPI.get_from_relation_config(model)
         elif model.config.materialized == "view":
             return ViewAPI.get_from_relation_config(model)
+        elif model.config.materialized == "metric_view":
+            return MetricViewAPI.get_from_relation_config(model)
         else:
             raise NotImplementedError(
                 f"Materialization {model.config.materialized} is not supported."
@@ -1152,3 +1157,29 @@ def _describe_relation(
             DESCRIBE_TABLE_EXTENDED_MACRO_NAME, kwargs=kwargs
         )
         return results
+
+
+class MetricViewAPI(RelationAPIBase[MetricViewConfig]):
+    relation_type = DatabricksRelationType.MetricView
+
+    @classmethod
+    def config_type(cls) -> type[MetricViewConfig]:
+        return MetricViewConfig
+
+    @classmethod
+    def _describe_relation(
+        cls, adapter: DatabricksAdapter, relation: DatabricksRelation
+    ) -> 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}
+        results["describe_extended"] = adapter.execute_macro(
+            DESCRIBE_TABLE_EXTENDED_MACRO_NAME, kwargs=kwargs
+        )
+        return results
diff --git a/dbt/adapters/databricks/relation.py b/dbt/adapters/databricks/relation.py
index 96394e8fc..44ed0e859 100644
--- a/dbt/adapters/databricks/relation.py
+++ b/dbt/adapters/databricks/relation.py
@@ -117,6 +117,10 @@ def is_hive_metastore(self) -> bool:
     def is_materialized_view(self) -> bool:
         return self.type == DatabricksRelationType.MaterializedView
 
+    @property
+    def is_metric_view(self) -> bool:
+        return self.type == DatabricksRelationType.MetricView
+
     @property
     def is_streaming_table(self) -> bool:
         return self.type == DatabricksRelationType.StreamingTable
diff --git a/dbt/adapters/databricks/relation_configs/metric_view.py b/dbt/adapters/databricks/relation_configs/metric_view.py
new file mode 100644
index 000000000..5a7322087
--- /dev/null
+++ b/dbt/adapters/databricks/relation_configs/metric_view.py
@@ -0,0 +1,52 @@
+from typing import Optional
+
+from typing_extensions import Self
+
+from dbt.adapters.databricks.logging import logger
+from dbt.adapters.databricks.relation_configs.base import (
+    DatabricksRelationChangeSet,
+    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 MetricViewConfig(DatabricksRelationConfigBase):
+    config_components = [
+        TagsProcessor,
+        TblPropertiesProcessor,
+        QueryProcessor,
+        CommentProcessor,
+        ColumnCommentsProcessor,
+        ColumnTagsProcessor,
+    ]
+
+    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
diff --git a/dbt/include/databricks/macros/materializations/metric_view.sql b/dbt/include/databricks/macros/materializations/metric_view.sql
new file mode 100644
index 000000000..4e765b54c
--- /dev/null
+++ b/dbt/include/databricks/macros/materializations/metric_view.sql
@@ -0,0 +1,31 @@
+{% materialization metric_view, adapter='databricks' -%}
+  {%- set existing_relation = load_relation_with_metadata(this) -%}
+  {%- set target_relation = this.incorporate(type='metric_view') -%}
+  {% set grant_config = config.get('grants') %}
+  {% set tags = config.get('databricks_tags') %}
+  {% set sql = adapter.clean_sql(sql) %}
+
+  {{ 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) }}
+  {% else %}
+    {% call statement('main') -%}
+      {{ get_create_metric_view_as_sql(target_relation, sql) }}
+    {%- endcall %}
+    {{ apply_tags(target_relation, tags) }}
+    {% 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 %}
+  {% endif %}
+
+  {% set should_revoke = should_revoke(existing_relation, full_refresh_mode=True) %}
+  {% do apply_grants(target_relation, grant_config, should_revoke=True) %}
+
+  {{ run_post_hooks() }}
+
+  {{ return({'relations': [target_relation]}) }}
+{%- endmaterialization %}
\ No newline at end of file
diff --git a/dbt/include/databricks/macros/materializations/view.sql b/dbt/include/databricks/macros/materializations/view.sql
index 8c824e5de..7ecc0829d 100644
--- a/dbt/include/databricks/macros/materializations/view.sql
+++ b/dbt/include/databricks/macros/materializations/view.sql
@@ -87,7 +87,7 @@
 
 {% macro relation_should_be_altered(existing_relation) %}
   {% set update_via_alter = config.get('view_update_via_alter', False) | as_bool %}
-  {% if existing_relation.is_view and update_via_alter %}
+  {% if (existing_relation.is_view or existing_relation.is_metric_view) and update_via_alter %}
     {% if existing_relation.is_hive_metastore() %}
       {{ exceptions.raise_compiler_error("Cannot update a view in the Hive metastore via ALTER VIEW. Please set `view_update_via_alter: false` in your model configuration.") }}
     {% endif %}
diff --git a/dbt/include/databricks/macros/relations/config.sql b/dbt/include/databricks/macros/relations/config.sql
index 4c6ae8910..0edd57463 100644
--- a/dbt/include/databricks/macros/relations/config.sql
+++ b/dbt/include/databricks/macros/relations/config.sql
@@ -3,4 +3,13 @@
     {%- set model_config = adapter.get_config_from_model(config.model) -%}
     {%- set configuration_changes = model_config.get_changeset(existing_config) -%}
     {% 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 -%}
\ No newline at end of file
diff --git a/dbt/include/databricks/macros/relations/create.sql b/dbt/include/databricks/macros/relations/create.sql
index fa96d19b6..abc442078 100644
--- a/dbt/include/databricks/macros/relations/create.sql
+++ b/dbt/include/databricks/macros/relations/create.sql
@@ -11,6 +11,9 @@
     {%- elif relation.is_streaming_table -%}
         {{ get_create_streaming_table_as_sql(relation, sql) }}
 
+    {%- elif relation.is_metric_view -%}
+        {{ get_create_metric_view_as_sql(relation, sql) }}
+
     {%- else -%}
         {{- exceptions.raise_compiler_error("`get_create_sql` has not been implemented for: " ~ relation.type ) -}}
 
diff --git a/dbt/include/databricks/macros/relations/drop.sql b/dbt/include/databricks/macros/relations/drop.sql
index 464ac51d2..710ad800f 100644
--- a/dbt/include/databricks/macros/relations/drop.sql
+++ b/dbt/include/databricks/macros/relations/drop.sql
@@ -3,7 +3,7 @@
         {{ drop_materialized_view(relation) }}
     {%- elif relation.is_streaming_table-%}
         {{ drop_streaming_table(relation) }}
-    {%- elif relation.is_view -%}
+    {%- elif relation.is_view or relation.is_metric_view -%}
         {{ drop_view(relation) }}
     {%- else -%}
         {{ drop_table(relation) }}
diff --git a/dbt/include/databricks/macros/relations/metric_view/alter.sql b/dbt/include/databricks/macros/relations/metric_view/alter.sql
new file mode 100644
index 000000000..af3429bb0
--- /dev/null
+++ b/dbt/include/databricks/macros/relations/metric_view/alter.sql
@@ -0,0 +1,36 @@
+{% macro alter_metric_view(target_relation, changes) %}
+  {{ log("Updating metric view via ALTER") }}
+  {{ adapter.dispatch('alter_metric_view', 'dbt')(target_relation, changes) }}
+{% endmacro %}
+
+{% macro databricks__alter_metric_view(target_relation, changes) %}
+  {% 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 #}
+  {% if tags %}
+    {{ apply_tags(target_relation, tags.set_tags) }}
+  {% endif %}
+  {% if tblproperties %}
+    {{ apply_tblproperties(target_relation, tblproperties.tblproperties) }}
+  {% endif %}
+
+  {# 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 %}
+{% endmacro %}
+
+{% macro replace_with_metric_view(existing_relation, target_relation) %}
+  {% set sql = adapter.clean_sql(sql) %}
+  {% set tags = config.get('databricks_tags') %}
+  {{ execute_multiple_statements(get_replace_sql(existing_relation, target_relation, sql)) }}
+  {%- do apply_tags(target_relation, tags) -%}
+
+  {% 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 %}
\ No newline at end of file
diff --git a/dbt/include/databricks/macros/relations/metric_view/create.sql b/dbt/include/databricks/macros/relations/metric_view/create.sql
new file mode 100644
index 000000000..6c8b386b9
--- /dev/null
+++ b/dbt/include/databricks/macros/relations/metric_view/create.sql
@@ -0,0 +1,12 @@
+{% macro get_create_metric_view_as_sql(relation, sql) -%}
+  {{ adapter.dispatch('get_create_metric_view_as_sql', 'dbt')(relation, sql) }}
+{%- endmacro %}
+
+{% macro databricks__get_create_metric_view_as_sql(relation, sql) %}
+create or replace view {{ relation.render() }}
+with metrics
+language yaml
+as $$
+{{ sql }}
+$$
+{% endmacro %}
\ No newline at end of file
diff --git a/dbt/include/databricks/macros/relations/metric_view/replace.sql b/dbt/include/databricks/macros/relations/metric_view/replace.sql
new file mode 100644
index 000000000..2855790ef
--- /dev/null
+++ b/dbt/include/databricks/macros/relations/metric_view/replace.sql
@@ -0,0 +1,7 @@
+{% macro get_replace_metric_view_sql(target_relation, sql) %}
+  {{ adapter.dispatch('get_replace_metric_view_sql', 'dbt')(target_relation, sql) }}
+{% endmacro %}
+
+{% macro databricks__get_replace_metric_view_sql(target_relation, sql) %}
+  {{ get_create_metric_view_as_sql(target_relation, sql) }}
+{% endmacro %}
\ No newline at end of file
diff --git a/dbt/include/databricks/macros/relations/replace.sql b/dbt/include/databricks/macros/relations/replace.sql
index 72484ede2..ff44c9d4d 100644
--- a/dbt/include/databricks/macros/relations/replace.sql
+++ b/dbt/include/databricks/macros/relations/replace.sql
@@ -9,6 +9,12 @@
     {{ exceptions.raise_not_implemented('get_replace_sql not implemented for target of table') }}
   {% endif %}
 
+  {#- Metric views always support CREATE OR REPLACE (no delta/file_format dependency) -#}
+  {#- Note: existing relation is typed as VIEW from DB, so check target for metric_view -#}
+  {% if target_relation.is_metric_view %}
+    {{ return(get_replace_metric_view_sql(target_relation, sql)) }}
+  {% endif %}
+
   {% set safe_replace = config.get('use_safer_relation_operations', False) | as_bool  %}
   {% set file_format = adapter.resolve_file_format(config) %}
   {% set is_replaceable = existing_relation.type == target_relation.type and existing_relation.can_be_replaced and file_format == "delta" %}
diff --git a/dbt/include/databricks/macros/relations/tags.sql b/dbt/include/databricks/macros/relations/tags.sql
index 6ba6e29a9..5916aa9a6 100644
--- a/dbt/include/databricks/macros/relations/tags.sql
+++ b/dbt/include/databricks/macros/relations/tags.sql
@@ -29,7 +29,12 @@
 {%- 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 -%}
     {% for tag in tags -%}
       '{{ tag }}' = '{{ tags[tag] }}' {%- if not loop.last %}, {% endif -%}
     {%- endfor %}
diff --git a/tests/functional/adapter/metric_views/fixtures.py b/tests/functional/adapter/metric_views/fixtures.py
new file mode 100644
index 000000000..180a8c796
--- /dev/null
+++ b/tests/functional/adapter/metric_views/fixtures.py
@@ -0,0 +1,63 @@
+source_table = """
+{{ config(materialized='table') }}
+
+select 1 as id, 100 as revenue, 'completed' as status, '2024-01-01' as order_date
+union all
+select 2 as id, 200 as revenue, 'pending' as status, '2024-01-02' as order_date
+union all
+select 3 as id, 150 as revenue, 'completed' as status, '2024-01-03' as order_date
+"""
+
+basic_metric_view = """
+{{ config(materialized='metric_view') }}
+
+version: 0.1
+source: "{{ ref('source_orders') }}"
+dimensions:
+  - name: order_date
+    expr: order_date
+  - name: status
+    expr: status
+measures:
+  - name: total_orders
+    expr: count(1)
+  - name: total_revenue
+    expr: sum(revenue)
+"""
+
+metric_view_with_filter = """
+{{ config(materialized='metric_view') }}
+
+version: 0.1
+source: "{{ ref('source_orders') }}"
+filter: status = 'completed'
+dimensions:
+  - name: order_date
+    expr: order_date
+measures:
+  - name: completed_orders
+    expr: count(1)
+  - name: completed_revenue
+    expr: sum(revenue)
+"""
+
+metric_view_with_config = """
+{{
+  config(
+    materialized='metric_view',
+    databricks_tags={
+      'team': 'analytics',
+      'environment': 'test'
+    }
+  )
+}}
+
+version: 0.1
+source: "{{ ref('source_orders') }}"
+dimensions:
+  - name: status
+    expr: status
+measures:
+  - name: order_count
+    expr: count(1)
+"""
diff --git a/tests/functional/adapter/metric_views/test_metric_view_configuration_changes.py b/tests/functional/adapter/metric_views/test_metric_view_configuration_changes.py
new file mode 100644
index 000000000..9693904b2
--- /dev/null
+++ b/tests/functional/adapter/metric_views/test_metric_view_configuration_changes.py
@@ -0,0 +1,201 @@
+import pytest
+from dbt.tests import util
+from dbt.tests.util import run_dbt
+
+from tests.functional.adapter.metric_views.fixtures import (
+    source_table,
+)
+
+# Test fixture for metric view with tags configuration
+metric_view_with_tags = """
+{{
+  config(
+    materialized='metric_view',
+    view_update_via_alter=true,
+    databricks_tags={
+      'team': 'analytics',
+      'environment': 'test'
+    }
+  )
+}}
+
+version: 0.1
+source: "{{ ref('source_orders') }}"
+dimensions:
+  - name: status
+    expr: status
+measures:
+  - name: total_orders
+    expr: count(1)
+  - name: total_revenue
+    expr: sum(revenue)
+"""
+
+# Updated tag configuration for testing ALTER
+metric_view_with_updated_tags = """
+{{
+  config(
+    materialized='metric_view',
+    view_update_via_alter=true,
+    databricks_tags={
+      'team': 'data-engineering',
+      'environment': 'production',
+      'owner': 'dbt-team'
+    }
+  )
+}}
+
+version: 0.1
+source: "{{ ref('source_orders') }}"
+dimensions:
+  - name: status
+    expr: status
+measures:
+  - name: total_orders
+    expr: count(1)
+  - name: total_revenue
+    expr: sum(revenue)
+"""
+
+# Changed YAML definition that requires CREATE OR REPLACE
+metric_view_with_changed_definition = """
+{{
+  config(
+    materialized='metric_view',
+    view_update_via_alter=true,
+    databricks_tags={
+      'team': 'analytics',
+      'environment': 'test'
+    }
+  )
+}}
+
+version: 0.1
+source: "{{ ref('source_orders') }}"
+dimensions:
+  - name: status
+    expr: status
+  - name: order_date
+    expr: order_date
+measures:
+  - name: total_orders
+    expr: count(1)
+  - name: total_revenue
+    expr: sum(revenue)
+  - name: avg_revenue
+    expr: avg(revenue)
+"""
+
+
+@pytest.mark.skip_profile("databricks_cluster")
+class TestMetricViewConfigurationChanges:
+    """Test metric view configuration change handling"""
+
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {
+            "source_orders.sql": source_table,
+            "config_change_metrics.sql": metric_view_with_tags,
+        }
+
+    def test_metric_view_tag_only_changes_via_alter(self, project):
+        """Test that tag-only changes use ALTER instead of CREATE OR REPLACE"""
+        # First run creates the metric view
+        results = run_dbt(["run"])
+        assert len(results) == 2
+        assert all(result.status == "success" for result in results)
+
+        # Update the model with different tags
+        util.write_file(metric_view_with_updated_tags, "models", "config_change_metrics.sql")
+
+        # Second run should use ALTER for tags
+        results = run_dbt(["run", "--models", "config_change_metrics"])
+        assert len(results) == 1
+        assert results[0].status == "success"
+
+        # Verify the metric view still works
+        metric_view_name = f"{project.database}.{project.test_schema}.config_change_metrics"
+        query_result = project.run_sql(
+            f"""
+            SELECT
+                status,
+                MEASURE(total_orders) as order_count,
+                MEASURE(total_revenue) as revenue
+            FROM {metric_view_name}
+            GROUP BY status
+            ORDER BY status
+        """,
+            fetch="all",
+        )
+
+        assert len(query_result) == 2
+        status_data = {row[0]: (row[1], row[2]) for row in query_result}
+        assert status_data["completed"] == (2, 250)
+        assert status_data["pending"] == (1, 200)
+
+    def test_metric_view_definition_changes_require_replace(self, project):
+        """Test that YAML definition changes use CREATE OR REPLACE"""
+        # First run creates the metric view
+        results = run_dbt(["run"])
+        assert len(results) == 2
+        assert all(result.status == "success" for result in results)
+
+        # Update the model with changed YAML definition
+        util.write_file(metric_view_with_changed_definition, "models", "config_change_metrics.sql")
+
+        # Second run should use CREATE OR REPLACE for YAML changes
+        results = run_dbt(["run", "--models", "config_change_metrics"])
+        assert len(results) == 1
+        assert results[0].status == "success"
+
+        # Verify the updated metric view works with new measure
+        metric_view_name = f"{project.database}.{project.test_schema}.config_change_metrics"
+        query_result = project.run_sql(
+            f"""
+            SELECT
+                status,
+                MEASURE(total_orders) as order_count,
+                MEASURE(total_revenue) as revenue,
+                MEASURE(avg_revenue) as avg_revenue
+            FROM {metric_view_name}
+            GROUP BY status
+            ORDER BY status
+        """,
+            fetch="all",
+        )
+
+        assert len(query_result) == 2
+        status_data = {row[0]: (row[1], row[2], row[3]) for row in query_result}
+        assert status_data["completed"] == (2, 250, 125.0)  # (100+150)/2 = 125
+        assert status_data["pending"] == (1, 200, 200.0)
+
+    def test_no_changes_skip_materialization(self, project):
+        """Test that no changes result in no-op"""
+        # First run creates the metric view
+        results = run_dbt(["run"])
+        assert len(results) == 2
+        assert all(result.status == "success" for result in results)
+
+        # Second run with no changes should be a no-op
+        results = run_dbt(["run", "--models", "config_change_metrics"])
+        assert len(results) == 1
+        assert results[0].status == "success"
+
+        # Verify the metric view still works
+        metric_view_name = f"{project.database}.{project.test_schema}.config_change_metrics"
+        query_result = project.run_sql(
+            f"""
+            SELECT
+                status,
+                MEASURE(total_orders) as order_count
+            FROM {metric_view_name}
+            GROUP BY status
+            ORDER BY status
+        """,
+            fetch="all",
+        )
+
+        assert len(query_result) == 2
+        status_data = {row[0]: row[1] for row in query_result}
+        assert status_data["completed"] == 2
+        assert status_data["pending"] == 1
diff --git a/tests/functional/adapter/metric_views/test_metric_view_materialization.py b/tests/functional/adapter/metric_views/test_metric_view_materialization.py
new file mode 100644
index 000000000..cee060184
--- /dev/null
+++ b/tests/functional/adapter/metric_views/test_metric_view_materialization.py
@@ -0,0 +1,213 @@
+import pytest
+from dbt.tests.util import get_manifest, run_dbt
+
+from tests.functional.adapter.metric_views.fixtures import (
+    basic_metric_view,
+    metric_view_with_config,
+    metric_view_with_filter,
+    source_table,
+)
+
+
+@pytest.mark.skip_profile("databricks_cluster")
+class TestBasicMetricViewMaterialization:
+    """Test basic metric view materialization functionality"""
+
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {
+            "source_orders.sql": source_table,
+            "order_metrics.sql": basic_metric_view,
+        }
+
+    def test_metric_view_creation(self, project):
+        """Test that metric view materialization creates a metric view successfully"""
+        # Run dbt to create the models
+        results = run_dbt(["run"])
+        assert len(results) == 2
+
+        # Verify both models ran successfully
+        assert all(result.status == "success" for result in results)
+
+        # Check that the metric view was created
+        manifest = get_manifest(project.project_root)
+        metric_view_node = manifest.nodes["model.test.order_metrics"]
+        assert metric_view_node.config.materialized == "metric_view"
+
+        # Test if the metric view actually works by querying it with MEASURE()
+        # This is the most important test - if this works, the metric view was created correctly
+        metric_view_name = f"{project.database}.{project.test_schema}.order_metrics"
+
+        try:
+            # Query the metric view using MEASURE() function - this is the real test
+            query_result = project.run_sql(
+                f"""
+                SELECT
+                    status,
+                    MEASURE(total_orders) as order_count,
+                    MEASURE(total_revenue) as revenue
+                FROM {metric_view_name}
+                GROUP BY status
+                ORDER BY status
+            """,
+                fetch="all",
+            )
+            print(f"Metric view query result: {query_result}")
+
+            # If we got results, verify the data is correct
+            if query_result:
+                assert len(query_result) == 2, f"Expected 2 status groups, got {len(query_result)}"
+
+                # Check data: 2 completed orders worth 250, 1 pending order worth 200
+                status_data = {row[0]: (row[1], row[2]) for row in query_result}
+                print(f"Status data: {status_data}")
+
+                assert "completed" in status_data, "Missing 'completed' status"
+                assert "pending" in status_data, "Missing 'pending' status"
+
+                completed_count, completed_revenue = status_data["completed"]
+                pending_count, pending_revenue = status_data["pending"]
+
+                assert completed_count == 2, f"Expected 2 completed orders, got {completed_count}"
+                assert completed_revenue == 250, (
+                    f"Expected 250 completed revenue, got {completed_revenue}"
+                )
+                assert pending_count == 1, f"Expected 1 pending order, got {pending_count}"
+                assert pending_revenue == 200, (
+                    f"Expected 200 pending revenue, got {pending_revenue}"
+                )
+
+                print("✅ Metric view query successful with correct data!")
+            else:
+                # fetch=True returned None, but let's try without fetch to see if it executes
+                project.run_sql(
+                    f"SELECT MEASURE(total_orders) FROM {metric_view_name} LIMIT 1", fetch=False
+                )
+                print("✅ Metric view query executed without error (but fetch returned None)")
+
+        except Exception as e:
+            assert False, f"Metric view query failed: {e}"
+
+    def test_metric_view_query(self, project):
+        """Test that the metric view can be queried using MEASURE() function"""
+        # First run dbt to create the models
+        run_dbt(["run"])
+
+        # Query the metric view using MEASURE() function
+        query_result = project.run_sql(
+            f"""
+            select
+                status,
+                measure(total_orders) as order_count,
+                measure(total_revenue) as revenue
+            from {project.database}.{project.test_schema}.order_metrics
+            group by status
+            order by status
+        """,
+            fetch="all",
+        )
+
+        # Verify we get expected results
+        assert len(query_result) == 2  # Should have 'completed' and 'pending' status
+
+        # Check the data makes sense
+        completed_row = next(row for row in query_result if row[0] == "completed")
+        pending_row = next(row for row in query_result if row[0] == "pending")
+
+        assert completed_row[1] == 2  # 2 completed orders
+        assert completed_row[2] == 250  # 100 + 150 revenue
+        assert pending_row[1] == 1  # 1 pending order
+        assert pending_row[2] == 200  # 200 revenue
+
+
+@pytest.mark.skip_profile("databricks_cluster")
+class TestMetricViewWithFilter:
+    """Test metric view materialization with filters"""
+
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {
+            "source_orders.sql": source_table,
+            "filtered_metrics.sql": metric_view_with_filter,
+        }
+
+    def test_metric_view_with_filter_creation(self, project):
+        """Test that metric view with filter works correctly"""
+        # Run dbt to create the models
+        results = run_dbt(["run"])
+        assert len(results) == 2
+
+        # Verify both models ran successfully
+        assert all(result.status == "success" for result in results)
+
+    def test_metric_view_with_filter_query(self, project):
+        """Test that filtered metric view returns expected results"""
+        # First run dbt to create the models
+        run_dbt(["run"])
+
+        # Query the filtered metric view
+        query_result = project.run_sql(
+            f"""
+            select
+                measure(completed_orders) as order_count,
+                measure(completed_revenue) as revenue
+            from {project.database}.{project.test_schema}.filtered_metrics
+        """,
+            fetch="all",
+        )
+
+        # Should only see completed orders (2 orders with 250 total revenue)
+        assert len(query_result) == 1
+        row = query_result[0]
+        assert row[0] == 2  # 2 completed orders
+        assert row[1] == 250  # 100 + 150 revenue from completed orders only
+
+
+@pytest.mark.skip_profile("databricks_cluster")
+class TestMetricViewConfiguration:
+    """Test metric view materialization with configuration options"""
+
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {
+            "source_orders.sql": source_table,
+            "config_metrics.sql": metric_view_with_config,
+        }
+
+    def test_metric_view_with_tags(self, project):
+        """Test that metric view works with databricks_tags using ALTER VIEW"""
+        # Run dbt to create the models
+        results = run_dbt(["run"])
+        assert len(results) == 2
+
+        # Verify both models ran successfully
+        assert all(result.status == "success" for result in results)
+
+        # Check that the metric view was created
+        manifest = get_manifest(project.project_root)
+        config_node = manifest.nodes["model.test.config_metrics"]
+        assert config_node.config.materialized == "metric_view"
+
+        # Verify the metric view works by querying it
+        metric_view_name = f"{project.database}.{project.test_schema}.config_metrics"
+
+        query_result = project.run_sql(
+            f"""
+            SELECT
+                status,
+                MEASURE(order_count) as count
+            FROM {metric_view_name}
+            GROUP BY status
+            ORDER BY status
+        """,
+            fetch="all",
+        )
+
+        # Should have results showing tags were applied without error
+        assert query_result is not None
+        assert len(query_result) == 2  # completed and pending statuses
+
+        # Check the data is correct
+        status_data = {row[0]: row[1] for row in query_result}
+        assert status_data["completed"] == 2
+        assert status_data["pending"] == 1
diff --git a/tests/functional/adapter/metric_views/test_metric_view_simple_changes.py b/tests/functional/adapter/metric_views/test_metric_view_simple_changes.py
new file mode 100644
index 000000000..aa012d17d
--- /dev/null
+++ b/tests/functional/adapter/metric_views/test_metric_view_simple_changes.py
@@ -0,0 +1,74 @@
+import pytest
+from dbt.tests.util import run_dbt
+
+from tests.functional.adapter.metric_views.fixtures import (
+    source_table,
+)
+
+# Test fixture for metric view without view_update_via_alter
+metric_view_without_alter = """
+{{
+  config(
+    materialized='metric_view',
+    databricks_tags={
+      'team': 'analytics',
+      'environment': 'test'
+    }
+  )
+}}
+
+version: 0.1
+source: "{{ ref('source_orders') }}"
+dimensions:
+  - name: status
+    expr: status
+measures:
+  - name: total_orders
+    expr: count(1)
+  - name: total_revenue
+    expr: sum(revenue)
+"""
+
+
+@pytest.mark.skip_profile("databricks_cluster")
+class TestMetricViewSimpleChanges:
+    """Test basic metric view behavior without configuration change detection"""
+
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {
+            "source_orders.sql": source_table,
+            "simple_metrics.sql": metric_view_without_alter,
+        }
+
+    def test_metric_view_always_recreates(self, project):
+        """Test that metric view recreates without view_update_via_alter"""
+        # First run creates the metric view
+        results = run_dbt(["run"])
+        assert len(results) == 2
+        assert all(result.status == "success" for result in results)
+
+        # Second run should recreate the metric view (full refresh behavior)
+        results = run_dbt(["run", "--models", "simple_metrics"])
+        assert len(results) == 1
+        assert results[0].status == "success"
+
+        # Verify the metric view still works
+        metric_view_name = f"{project.database}.{project.test_schema}.simple_metrics"
+        query_result = project.run_sql(
+            f"""
+            SELECT
+                status,
+                MEASURE(total_orders) as order_count,
+                MEASURE(total_revenue) as revenue
+            FROM {metric_view_name}
+            GROUP BY status
+            ORDER BY status
+        """,
+            fetch="all",
+        )
+
+        assert len(query_result) == 2
+        status_data = {row[0]: (row[1], row[2]) for row in query_result}
+        assert status_data["completed"] == (2, 250)
+        assert status_data["pending"] == (1, 200)
diff --git a/tests/unit/macros/relations/test_metric_view_create.py b/tests/unit/macros/relations/test_metric_view_create.py
new file mode 100644
index 000000000..d8e88ded1
--- /dev/null
+++ b/tests/unit/macros/relations/test_metric_view_create.py
@@ -0,0 +1,148 @@
+import pytest
+
+from tests.unit.macros.base import MacroTestBase
+
+
+class TestGetCreateMetricViewAsSQL(MacroTestBase):
+    @pytest.fixture(scope="class")
+    def template_name(self) -> str:
+        return "create.sql"
+
+    @pytest.fixture(scope="class")
+    def macro_folders_to_load(self) -> list:
+        return ["macros", "macros/relations/metric_view"]
+
+    def test_basic_metric_view_creation(self, template_bundle):
+        """Test that get_create_metric_view_as_sql generates correct Databricks SQL"""
+        yaml_spec = """version: 0.1
+source: orders
+dimensions:
+  - name: order_date
+    expr: order_date
+measures:
+  - name: order_count
+    expr: count(1)"""
+
+        result = self.run_macro_raw(
+            template_bundle.template,
+            "databricks__get_create_metric_view_as_sql",
+            template_bundle.relation,
+            yaml_spec,
+        )
+
+        expected = """create or replace view `some_database`.`some_schema`.`some_table`
+with metrics
+language yaml
+as $$
+version: 0.1
+source: orders
+dimensions:
+  - name: order_date
+    expr: order_date
+measures:
+  - name: order_count
+    expr: count(1)
+$$"""
+
+        # For metric views, we need to preserve YAML formatting exactly
+        assert result.strip() == expected.strip()
+
+    def test_metric_view_with_filter(self, template_bundle):
+        """Test metric view generation with filter clause"""
+        yaml_spec = """version: 0.1
+source: orders
+filter: status = 'completed'
+dimensions:
+  - name: order_date
+    expr: order_date
+measures:
+  - name: revenue
+    expr: sum(amount)"""
+
+        result = self.run_macro_raw(
+            template_bundle.template,
+            "databricks__get_create_metric_view_as_sql",
+            template_bundle.relation,
+            yaml_spec,
+        )
+
+        expected = """create or replace view `some_database`.`some_schema`.`some_table`
+with metrics
+language yaml
+as $$
+version: 0.1
+source: orders
+filter: status = 'completed'
+dimensions:
+  - name: order_date
+    expr: order_date
+measures:
+  - name: revenue
+    expr: sum(amount)
+$$"""
+
+        assert result.strip() == expected.strip()
+
+    def test_complex_metric_view(self, template_bundle):
+        """Test metric view with multiple dimensions and measures"""
+        yaml_spec = """version: 0.1
+source: customer_orders
+filter: order_date >= '2024-01-01'
+dimensions:
+  - name: customer_segment
+    expr: customer_type
+  - name: order_month
+    expr: date_trunc('MONTH', order_date)
+measures:
+  - name: total_orders
+    expr: count(1)
+  - name: total_revenue
+    expr: sum(order_total)
+  - name: avg_order_value
+    expr: avg(order_total)"""
+
+        result = self.run_macro_raw(
+            template_bundle.template,
+            "databricks__get_create_metric_view_as_sql",
+            template_bundle.relation,
+            yaml_spec,
+        )
+
+        # Check that all key parts are present
+        assert "create or replace view" in result.lower()
+        assert "with metrics" in result.lower()
+        assert "language yaml" in result.lower()
+        assert "as $$" in result.lower()
+        assert result.strip().endswith("$$")
+        assert "version: 0.1" in result
+        assert "source: customer_orders" in result
+        assert "filter: order_date >= '2024-01-01'" in result
+        assert "customer_segment" in result
+        assert "total_revenue" in result
+
+    def test_generic_macro_dispatcher(self, template_bundle):
+        """Test that the generic get_create_metric_view_as_sql macro works"""
+        yaml_spec = """version: 0.1
+source: test_table
+measures:
+  - name: count
+    expr: count(1)"""
+
+        # Mock the adapter dispatch to return our databricks implementation
+        template_bundle.context["adapter"].dispatch.return_value = getattr(
+            template_bundle.template.module, "databricks__get_create_metric_view_as_sql"
+        )
+
+        result = self.run_macro_raw(
+            template_bundle.template,
+            "get_create_metric_view_as_sql",
+            template_bundle.relation,
+            yaml_spec,
+        )
+
+        # Should generate the same output as the databricks-specific macro
+        assert "create or replace view" in result.lower()
+        assert "with metrics" in result.lower()
+        assert "language yaml" in result.lower()
+        assert "version: 0.1" in result
+        assert "source: test_table" in result