ADAP-387: Stub materialized view as a materialization

core/dbt/include/global_project/macros/db_api/materialized_view/create.sql

@@ -0,0 +1,10 @@
+{% macro db_api__create_materialized_view_as(relation, sql) %}
+    {{ adapter.dispatch('db_api__create_materialized_view_as', 'dbt')(relation, sql) }}
+{% endmacro %}
+
+{% macro default_db_api__create_materialized_view_as(relation, sql) -%}
+
+    {{ exceptions.raise_not_implemented(
+    'db_api__create_materialized_view_as macro not implemented for adapter '+adapter.type()) }}
+
+{% endmacro %}

core/dbt/include/global_project/macros/db_api/materialized_view/refresh.sql

@@ -0,0 +1,10 @@
+{% macro db_api__materialized_view_refresh(relation) %}
+    {{ adapter.dispatch('db_api__materialized_view__refresh', 'dbt')(relation) }}
+{% endmacro %}
+
+{% macro default__db_api__materialized_view_refresh(relation) -%}
+
+    {{ exceptions.raise_not_implemented(
+    'db_api__materialized_view__refresh not implemented for adapter '+adapter.type()) }}
+
+{% endmacro %}

core/dbt/include/global_project/macros/materializations/models/materialized_view/materialized_view.sql

@@ -0,0 +1,72 @@
+{%- materialization materialized_view, default -%}
+  {% set full_refresh_mode = should_full_refresh() %}
+  {%- set existing_relation = load_cached_relation(this) -%}
+  {%- set target_relation = this.incorporate(type='view') -%}
+  {%- set intermediate_relation =  make_intermediate_relation(target_relation) -%}
+
+  -- the intermediate_relation should not already exist in the database; get_relation
+  -- will return None in that case. Otherwise, we get a relation that we can drop
+  -- later, before we try to use this name for the current operation
+  {%- set preexisting_intermediate_relation = load_cached_relation(intermediate_relation) -%}
+  /*
+     This relation (probably) doesn't exist yet. If it does exist, it's a leftover from
+     a previous run, and we're going to try to drop it immediately. At the end of this
+     materialization, we're going to rename the "existing_relation" to this identifier,
+     and then we're going to drop it. In order to make sure we run the correct one of:
+       - drop view ...
+       - drop table ...
+     We need to set the type of this relation to be the type of the existing_relation, if it exists,
+     or else "view" as a sane default if it does not. Note that if the existing_relation does not
+     exist, then there is nothing to move out of the way and subsequentally drop. In that case,
+     this relation will be effectively unused.
+  */
+  {%- set backup_relation_type = 'view' if existing_relation is none else existing_relation.type -%}
+  {%- set backup_relation = make_backup_relation(target_relation, backup_relation_type) -%}
+  -- as above, the backup_relation should not already exist
+  {%- set preexisting_backup_relation = load_cached_relation(backup_relation) -%}
+  -- grab current tables grants config for comparision later on
+  {% set grant_config = config.get('grants') %}
+
+  {{ run_hooks(pre_hooks, inside_transaction=False) }}
+
+  -- drop the temp relations if they exist already in the database
+  {{ drop_relation_if_exists(preexisting_intermediate_relation) }}
+  {{ drop_relation_if_exists(preexisting_backup_relation) }}
+
+  -- `BEGIN` happens here:
+  {{ run_hooks(pre_hooks, inside_transaction=True) }}
+
+  -- cleanup
+  -- move the existing view out of the way
+  {% if existing_relation is none %}
+      {% set build_sql = strategy__materialized_view__create(target_relation, sql) %}
+  {% elif full_refresh_mode or existing_relation.type != 'view' %}
+      {% do adapter.rename_relation(target_relation, backup_relation) %}
+      {% set build_sql = strategy__materialized_view__create(target_relation, sql) %}
+  {% else %}
+      {% set build_sql = strategy__materialized_view__full_refresh(target_relation) %}
+  {% endif %}
+
+    -- possible conditional wrapper for build_sql statement based on configs as a option?
+    -- build model
+  {% call statement("main") %}
+      {{ build_sql }}
+  {% endcall %}
+
+  {% set should_revoke = should_revoke(existing_relation, full_refresh_mode=True) %}
+  {% do apply_grants(target_relation, grant_config, should_revoke=should_revoke) %}
+
+  {% do persist_docs(target_relation, model) %}
+
+  {{ run_hooks(post_hooks, inside_transaction=True) }}
+
+  {{ adapter.commit() }}
+
+  {{ drop_relation_if_exists(backup_relation) }}
+  {{ drop_relation_if_exists(intermediate_relation) }}
+
+  {{ run_hooks(post_hooks, inside_transaction=False) }}
+
+  {{ return({'relations': [target_relation]}) }}
+
+{%- endmaterialization -%}

core/dbt/include/global_project/macros/strategies/materialized_view/create.sql

@@ -0,0 +1,3 @@
+{% macro strategy__materialized_view__create(relation, sql) %}
+    {{ db_api__create_materialized_view_as(relation, sql) }}
+{% endmacro %}

core/dbt/include/global_project/macros/strategies/materialized_view/full_refresh.sql

@@ -0,0 +1,4 @@
+{% macro strategy__materialized_view__full_refresh(relation, sql) %}
+    {{ drop_relation_if_exists(relation) }}
+    {{ db_api__create_materialized_view_as(relation, sql) }}
+{% endmacro %}

tests/functional/materializations/test_materialized_view_materialization.py

@@ -0,0 +1,19 @@
+import pytest
+
+from dbt.tests.util import run_dbt
+
+
+models__model_sql = """
+{{ config(materialized='materialized_view') }}
+select 1 as id
+
+"""
+
+
+@pytest.fixture(scope="class")
+def models():
+    return {"model.sql": models__model_sql}
+
+
+def test_basic(project):
+    run_dbt(["run"], expect_pass=False)