dbt-adapters 0.1.0a1__py3-none-any.whl

dbt/include/global_project/macros/relations/column/columns_spec_ddl.sql

@@ -0,0 +1,89 @@
+{%- macro get_table_columns_and_constraints() -%}
+  {{ adapter.dispatch('get_table_columns_and_constraints', 'dbt')() }}
+{%- endmacro -%}
+
+{% macro default__get_table_columns_and_constraints() -%}
+  {{ return(table_columns_and_constraints()) }}
+{%- endmacro %}
+
+{% macro table_columns_and_constraints() %}
+  {# loop through user_provided_columns to create DDL with data types and constraints #}
+    {%- set raw_column_constraints = adapter.render_raw_columns_constraints(raw_columns=model['columns']) -%}
+    {%- set raw_model_constraints = adapter.render_raw_model_constraints(raw_constraints=model['constraints']) -%}
+    (
+    {% for c in raw_column_constraints -%}
+      {{ c }}{{ "," if not loop.last or raw_model_constraints }}
+    {% endfor %}
+    {% for c in raw_model_constraints -%}
+        {{ c }}{{ "," if not loop.last }}
+    {% endfor -%}
+    )
+{% endmacro %}
+
+{%- macro get_assert_columns_equivalent(sql) -%}
+  {{ adapter.dispatch('get_assert_columns_equivalent', 'dbt')(sql) }}
+{%- endmacro -%}
+
+{% macro default__get_assert_columns_equivalent(sql) -%}
+  {{ return(assert_columns_equivalent(sql)) }}
+{%- endmacro %}
+
+{#
+  Compares the column schema provided by a model's sql file to the column schema provided by a model's schema file.
+  If any differences in name, data_type or number of columns exist between the two schemas, raises a compiler error
+#}
+{% macro assert_columns_equivalent(sql) %}
+
+  {#-- First ensure the user has defined 'columns' in yaml specification --#}
+  {%- set user_defined_columns = model['columns'] -%}
+  {%- if not user_defined_columns -%}
+      {{ exceptions.raise_contract_error([], []) }}
+  {%- endif -%}
+
+  {#-- Obtain the column schema provided by sql file. #}
+  {%- set sql_file_provided_columns = get_column_schema_from_query(sql, config.get('sql_header', none)) -%}
+  {#--Obtain the column schema provided by the schema file by generating an 'empty schema' query from the model's columns. #}
+  {%- set schema_file_provided_columns = get_column_schema_from_query(get_empty_schema_sql(user_defined_columns)) -%}
+
+  {#-- create dictionaries with name and formatted data type and strings for exception #}
+  {%- set sql_columns = format_columns(sql_file_provided_columns) -%}
+  {%- set yaml_columns = format_columns(schema_file_provided_columns)  -%}
+
+  {%- if sql_columns|length != yaml_columns|length -%}
+    {%- do exceptions.raise_contract_error(yaml_columns, sql_columns) -%}
+  {%- endif -%}
+
+  {%- for sql_col in sql_columns -%}
+    {%- set yaml_col = [] -%}
+    {%- for this_col in yaml_columns -%}
+      {%- if this_col['name'] == sql_col['name'] -%}
+        {%- do yaml_col.append(this_col) -%}
+        {%- break -%}
+      {%- endif -%}
+    {%- endfor -%}
+    {%- if not yaml_col -%}
+      {#-- Column with name not found in yaml #}
+      {%- do exceptions.raise_contract_error(yaml_columns, sql_columns) -%}
+    {%- endif -%}
+    {%- if sql_col['formatted'] != yaml_col[0]['formatted'] -%}
+      {#-- Column data types don't match #}
+      {%- do exceptions.raise_contract_error(yaml_columns, sql_columns) -%}
+    {%- endif -%}
+  {%- endfor -%}
+
+{% endmacro %}
+
+{% macro format_columns(columns) %}
+  {% set formatted_columns = [] %}
+  {% for column in columns %}
+    {%- set formatted_column = adapter.dispatch('format_column', 'dbt')(column) -%}
+    {%- do formatted_columns.append(formatted_column) -%}
+  {% endfor %}
+  {{ return(formatted_columns) }}
+{% endmacro %}
+
+{% macro default__format_column(column) -%}
+  {% set data_type = column.dtype %}
+  {% set formatted = column.column.lower() ~ " " ~ data_type %}
+  {{ return({'name': column.name, 'data_type': data_type, 'formatted': formatted}) }}
+{%- endmacro -%}

dbt/include/global_project/macros/relations/create.sql

@@ -0,0 +1,23 @@
+{%- macro get_create_sql(relation, sql) -%}
+    {{- log('Applying CREATE to: ' ~ relation) -}}
+    {{- adapter.dispatch('get_create_sql', 'dbt')(relation, sql) -}}
+{%- endmacro -%}
+
+
+{%- macro default__get_create_sql(relation, sql) -%}
+
+    {%- if relation.is_view -%}
+        {{ get_create_view_as_sql(relation, sql) }}
+
+    {%- elif relation.is_table -%}
+        {{ get_create_table_as_sql(False, relation, sql) }}
+
+    {%- elif relation.is_materialized_view -%}
+        {{ get_create_materialized_view_as_sql(relation, sql) }}
+
+    {%- else -%}
+        {{- exceptions.raise_compiler_error("`get_create_sql` has not been implemented for: " ~ relation.type ) -}}
+
+    {%- endif -%}
+
+{%- endmacro -%}

dbt/include/global_project/macros/relations/create_backup.sql

@@ -0,0 +1,17 @@
+{%- macro get_create_backup_sql(relation) -%}
+    {{- log('Applying CREATE BACKUP to: ' ~ relation) -}}
+    {{- adapter.dispatch('get_create_backup_sql', 'dbt')(relation) -}}
+{%- endmacro -%}
+
+
+{%- macro default__get_create_backup_sql(relation) -%}
+
+    -- get the standard backup name
+    {% set backup_relation = make_backup_relation(relation, relation.type) %}
+
+    -- drop any pre-existing backup
+    {{ get_drop_sql(backup_relation) }};
+
+    {{ get_rename_sql(relation, backup_relation.identifier) }}
+
+{%- endmacro -%}

dbt/include/global_project/macros/relations/create_intermediate.sql

@@ -0,0 +1,17 @@
+{%- macro get_create_intermediate_sql(relation, sql) -%}
+    {{- log('Applying CREATE INTERMEDIATE to: ' ~ relation) -}}
+    {{- adapter.dispatch('get_create_intermediate_sql', 'dbt')(relation, sql) -}}
+{%- endmacro -%}
+
+
+{%- macro default__get_create_intermediate_sql(relation, sql) -%}
+
+    -- get the standard intermediate name
+    {% set intermediate_relation = make_intermediate_relation(relation) %}
+
+    -- drop any pre-existing intermediate
+    {{ get_drop_sql(intermediate_relation) }};
+
+    {{ get_create_sql(intermediate_relation, sql) }}
+
+{%- endmacro -%}

dbt/include/global_project/macros/relations/drop.sql

@@ -0,0 +1,41 @@
+{%- macro get_drop_sql(relation) -%}
+    {{- log('Applying DROP to: ' ~ relation) -}}
+    {{- adapter.dispatch('get_drop_sql', 'dbt')(relation) -}}
+{%- endmacro -%}
+
+
+{%- macro default__get_drop_sql(relation) -%}
+
+    {%- if relation.is_view -%}
+        {{ drop_view(relation) }}
+
+    {%- elif relation.is_table -%}
+        {{ drop_table(relation) }}
+
+    {%- elif relation.is_materialized_view -%}
+        {{ drop_materialized_view(relation) }}
+
+    {%- else -%}
+        drop {{ relation.type }} if exists {{ relation }} cascade
+
+    {%- endif -%}
+
+{%- endmacro -%}
+
+
+{% macro drop_relation(relation) -%}
+    {{ return(adapter.dispatch('drop_relation', 'dbt')(relation)) }}
+{% endmacro %}
+
+{% macro default__drop_relation(relation) -%}
+    {% call statement('drop_relation', auto_begin=False) -%}
+        {{ get_drop_sql(relation) }}
+    {%- endcall %}
+{% endmacro %}
+
+
+{% macro drop_relation_if_exists(relation) %}
+  {% if relation is not none %}
+    {{ adapter.drop_relation(relation) }}
+  {% endif %}
+{% endmacro %}

dbt/include/global_project/macros/relations/drop_backup.sql

@@ -0,0 +1,14 @@
+{%- macro get_drop_backup_sql(relation) -%}
+    {{- log('Applying DROP BACKUP to: ' ~ relation) -}}
+    {{- adapter.dispatch('get_drop_backup_sql', 'dbt')(relation) -}}
+{%- endmacro -%}
+
+
+{%- macro default__get_drop_backup_sql(relation) -%}
+
+    -- get the standard backup name
+    {% set backup_relation = make_backup_relation(relation, relation.type) %}
+
+    {{ get_drop_sql(backup_relation) }}
+
+{%- endmacro -%}

dbt/include/global_project/macros/relations/materialized_view/alter.sql

@@ -0,0 +1,55 @@
+{% macro get_alter_materialized_view_as_sql(
+    relation,
+    configuration_changes,
+    sql,
+    existing_relation,
+    backup_relation,
+    intermediate_relation
+) %}
+    {{- log('Applying ALTER to: ' ~ relation) -}}
+    {{- adapter.dispatch('get_alter_materialized_view_as_sql', 'dbt')(
+        relation,
+        configuration_changes,
+        sql,
+        existing_relation,
+        backup_relation,
+        intermediate_relation
+    ) -}}
+{% endmacro %}
+
+
+{% macro default__get_alter_materialized_view_as_sql(
+    relation,
+    configuration_changes,
+    sql,
+    existing_relation,
+    backup_relation,
+    intermediate_relation
+) %}
+    {{ exceptions.raise_compiler_error("Materialized views have not been implemented for this adapter.") }}
+{% endmacro %}
+
+
+{% macro get_materialized_view_configuration_changes(existing_relation, new_config) %}
+    /* {#
+    It's recommended that configuration changes be formatted as follows:
+    {"<change_category>": [{"action": "<name>", "context": ...}]}
+
+    For example:
+    {
+        "indexes": [
+            {"action": "drop", "context": "index_abc"},
+            {"action": "create", "context": {"columns": ["column_1", "column_2"], "type": "hash", "unique": True}},
+        ],
+    }
+
+    Either way, `get_materialized_view_configuration_changes` needs to align with `get_alter_materialized_view_as_sql`.
+    #} */
+    {{- log('Determining configuration changes on: ' ~ existing_relation) -}}
+    {%- do return(adapter.dispatch('get_materialized_view_configuration_changes', 'dbt')(existing_relation, new_config)) -%}
+{% endmacro %}
+
+
+{% macro default__get_materialized_view_configuration_changes(existing_relation, new_config) %}
+    {{ exceptions.raise_compiler_error("Materialized views have not been implemented for this adapter.") }}
+{% endmacro %}

dbt/include/global_project/macros/relations/materialized_view/create.sql

@@ -0,0 +1,10 @@
+{% macro get_create_materialized_view_as_sql(relation, sql) -%}
+    {{- adapter.dispatch('get_create_materialized_view_as_sql', 'dbt')(relation, sql) -}}
+{%- endmacro %}
+
+
+{% macro default__get_create_materialized_view_as_sql(relation, sql) -%}
+    {{ exceptions.raise_compiler_error(
+        "`get_create_materialized_view_as_sql` has not been implemented for this adapter."
+    ) }}
+{% endmacro %}

dbt/include/global_project/macros/relations/materialized_view/drop.sql

@@ -0,0 +1,14 @@
+{# /*
+This was already implemented. Instead of creating a new macro that aligns with the standard,
+this was reused and the default was maintained. This gets called by `drop_relation`, which
+actually executes the drop, and `get_drop_sql`, which returns the template.
+*/ #}
+
+{% macro drop_materialized_view(relation) -%}
+    {{ return(adapter.dispatch('drop_materialized_view', 'dbt')(relation)) }}
+{%- endmacro %}
+
+
+{% macro default__drop_materialized_view(relation) -%}
+    drop materialized view if exists {{ relation }} cascade
+{%- endmacro %}

dbt/include/global_project/macros/relations/materialized_view/refresh.sql

@@ -0,0 +1,9 @@
+{% macro refresh_materialized_view(relation) %}
+    {{- log('Applying REFRESH to: ' ~ relation) -}}
+    {{- adapter.dispatch('refresh_materialized_view', 'dbt')(relation) -}}
+{% endmacro %}
+
+
+{% macro default__refresh_materialized_view(relation) %}
+    {{ exceptions.raise_compiler_error("`refresh_materialized_view` has not been implemented for this adapter.") }}
+{% endmacro %}

dbt/include/global_project/macros/relations/materialized_view/rename.sql

@@ -0,0 +1,10 @@
+{% macro get_rename_materialized_view_sql(relation, new_name) %}
+    {{- adapter.dispatch('get_rename_materialized_view_sql', 'dbt')(relation, new_name) -}}
+{% endmacro %}
+
+
+{% macro default__get_rename_materialized_view_sql(relation, new_name) %}
+    {{ exceptions.raise_compiler_error(
+        "`get_rename_materialized_view_sql` has not been implemented for this adapter."
+    ) }}
+{% endmacro %}

dbt/include/global_project/macros/relations/materialized_view/replace.sql

@@ -0,0 +1,10 @@
+{% macro get_replace_materialized_view_sql(relation, sql) %}
+    {{- adapter.dispatch('get_replace_materialized_view_sql', 'dbt')(relation, sql) -}}
+{% endmacro %}
+
+
+{% macro default__get_replace_materialized_view_sql(relation, sql) %}
+    {{ exceptions.raise_compiler_error(
+        "`get_replace_materialized_view_sql` has not been implemented for this adapter."
+    ) }}
+{% endmacro %}

dbt/include/global_project/macros/relations/rename.sql

@@ -0,0 +1,35 @@
+{%- macro get_rename_sql(relation, new_name) -%}
+    {{- log('Applying RENAME to: ' ~ relation) -}}
+    {{- adapter.dispatch('get_rename_sql', 'dbt')(relation, new_name) -}}
+{%- endmacro -%}
+
+
+{%- macro default__get_rename_sql(relation, new_name) -%}
+
+    {%- if relation.is_view -%}
+        {{ get_rename_view_sql(relation, new_name) }}
+
+    {%- elif relation.is_table -%}
+        {{ get_rename_table_sql(relation, new_name) }}
+
+    {%- elif relation.is_materialized_view -%}
+        {{ get_rename_materialized_view_sql(relation, new_name) }}
+
+    {%- else -%}
+        {{- exceptions.raise_compiler_error("`get_rename_sql` has not been implemented for: " ~ relation.type ) -}}
+
+    {%- endif -%}
+
+{%- endmacro -%}
+
+
+{% macro rename_relation(from_relation, to_relation) -%}
+  {{ return(adapter.dispatch('rename_relation', 'dbt')(from_relation, to_relation)) }}
+{% endmacro %}
+
+{% macro default__rename_relation(from_relation, to_relation) -%}
+  {% set target_name = adapter.quote_as_configured(to_relation.identifier, 'identifier') %}
+  {% call statement('rename_relation') -%}
+    alter table {{ from_relation }} rename to {{ target_name }}
+  {%- endcall %}
+{% endmacro %}

dbt/include/global_project/macros/relations/rename_intermediate.sql

@@ -0,0 +1,14 @@
+{%- macro get_rename_intermediate_sql(relation) -%}
+    {{- log('Applying RENAME INTERMEDIATE to: ' ~ relation) -}}
+    {{- adapter.dispatch('get_rename_intermediate_sql', 'dbt')(relation) -}}
+{%- endmacro -%}
+
+
+{%- macro default__get_rename_intermediate_sql(relation) -%}
+
+    -- get the standard intermediate name
+    {% set intermediate_relation = make_intermediate_relation(relation) %}
+
+    {{ get_rename_sql(intermediate_relation, relation.identifier) }}
+
+{%- endmacro -%}

dbt/include/global_project/macros/relations/replace.sql

@@ -0,0 +1,50 @@
+{% macro get_replace_sql(existing_relation, target_relation, sql) %}
+    {{- log('Applying REPLACE to: ' ~ existing_relation) -}}
+    {{- adapter.dispatch('get_replace_sql', 'dbt')(existing_relation, target_relation, sql) -}}
+{% endmacro %}
+
+
+{% macro default__get_replace_sql(existing_relation, target_relation, sql) %}
+
+    {# /* use a create or replace statement if possible */ #}
+
+    {% set is_replaceable = existing_relation.type == target_relation_type and existing_relation.can_be_replaced %}
+
+    {% if is_replaceable and existing_relation.is_view %}
+        {{ get_replace_view_sql(target_relation, sql) }}
+
+    {% elif is_replaceable and existing_relation.is_table %}
+        {{ get_replace_table_sql(target_relation, sql) }}
+
+    {% elif is_replaceable and existing_relation.is_materialized_view %}
+        {{ get_replace_materialized_view_sql(target_relation, sql) }}
+
+    {# /* a create or replace statement is not possible, so try to stage and/or backup to be safe */ #}
+
+    {# /* create target_relation as an intermediate relation, then swap it out with the existing one using a backup */ #}
+    {%- elif target_relation.can_be_renamed and existing_relation.can_be_renamed -%}
+        {{ get_create_intermediate_sql(target_relation, sql) }};
+        {{ get_create_backup_sql(existing_relation) }};
+        {{ get_rename_intermediate_sql(target_relation) }};
+        {{ get_drop_backup_sql(existing_relation) }}
+
+    {# /* create target_relation as an intermediate relation, then swap it out with the existing one without using a backup */ #}
+    {%- elif target_relation.can_be_renamed -%}
+        {{ get_create_intermediate_sql(target_relation, sql) }};
+        {{ get_drop_sql(existing_relation) }};
+        {{ get_rename_intermediate_sql(target_relation) }}
+
+    {# /* create target_relation in place by first backing up the existing relation */ #}
+    {%- elif existing_relation.can_be_renamed -%}
+        {{ get_create_backup_sql(existing_relation) }};
+        {{ get_create_sql(target_relation, sql) }};
+        {{ get_drop_backup_sql(existing_relation) }}
+
+    {# /* no renaming is allowed, so just drop and create */ #}
+    {%- else -%}
+        {{ get_drop_sql(existing_relation) }};
+        {{ get_create_sql(target_relation, sql) }}
+
+    {%- endif -%}
+
+{% endmacro %}

dbt/include/global_project/macros/relations/schema.sql

@@ -0,0 +1,8 @@
+{% macro drop_schema_named(schema_name) %}
+    {{ return(adapter.dispatch('drop_schema_named', 'dbt') (schema_name)) }}
+{% endmacro %}
+
+{% macro default__drop_schema_named(schema_name) %}
+  {% set schema_relation = api.Relation.create(schema=schema_name) %}
+  {{ adapter.drop_schema(schema_relation) }}
+{% endmacro %}

dbt/include/global_project/macros/relations/table/create.sql

@@ -0,0 +1,60 @@
+{% macro get_create_table_as_sql(temporary, relation, sql) -%}
+  {{ adapter.dispatch('get_create_table_as_sql', 'dbt')(temporary, relation, sql) }}
+{%- endmacro %}
+
+{% macro default__get_create_table_as_sql(temporary, relation, sql) -%}
+  {{ return(create_table_as(temporary, relation, sql)) }}
+{% endmacro %}
+
+
+/* {# keep logic under old macro name for backwards compatibility #} */
+{% macro create_table_as(temporary, relation, compiled_code, language='sql') -%}
+  {# backward compatibility for create_table_as that does not support language #}
+  {% if language == "sql" %}
+    {{ adapter.dispatch('create_table_as', 'dbt')(temporary, relation, compiled_code)}}
+  {% else %}
+    {{ adapter.dispatch('create_table_as', 'dbt')(temporary, relation, compiled_code, language) }}
+  {% endif %}
+
+{%- endmacro %}
+
+{% macro default__create_table_as(temporary, relation, sql) -%}
+  {%- set sql_header = config.get('sql_header', none) -%}
+
+  {{ sql_header if sql_header is not none }}
+
+  create {% if temporary: -%}temporary{%- endif %} table
+    {{ relation.include(database=(not temporary), schema=(not temporary)) }}
+  {% set contract_config = config.get('contract') %}
+  {% if contract_config.enforced and (not temporary) %}
+    {{ get_assert_columns_equivalent(sql) }}
+    {{ get_table_columns_and_constraints() }}
+    {%- set sql = get_select_subquery(sql) %}
+  {% endif %}
+  as (
+    {{ sql }}
+  );
+{%- endmacro %}
+
+
+{% macro default__get_column_names() %}
+  {#- loop through user_provided_columns to get column names -#}
+    {%- set user_provided_columns = model['columns'] -%}
+    {%- for i in user_provided_columns %}
+      {%- set col = user_provided_columns[i] -%}
+      {%- set col_name = adapter.quote(col['name']) if col.get('quote') else col['name'] -%}
+      {{ col_name }}{{ ", " if not loop.last }}
+    {%- endfor -%}
+{% endmacro %}
+
+
+{% macro get_select_subquery(sql) %}
+  {{ return(adapter.dispatch('get_select_subquery', 'dbt')(sql)) }}
+{% endmacro %}
+
+{% macro default__get_select_subquery(sql) %}
+    select {{ adapter.dispatch('get_column_names', 'dbt')() }}
+    from (
+        {{ sql }}
+    ) as model_subq
+{%- endmacro %}

dbt/include/global_project/macros/relations/table/drop.sql

@@ -0,0 +1,14 @@
+{# /*
+This was already implemented. Instead of creating a new macro that aligns with the standard,
+this was reused and the default was maintained. This gets called by `drop_relation`, which
+actually executes the drop, and `get_drop_sql`, which returns the template.
+*/ #}
+
+{% macro drop_table(relation) -%}
+    {{ return(adapter.dispatch('drop_table', 'dbt')(relation)) }}
+{%- endmacro %}
+
+
+{% macro default__drop_table(relation) -%}
+    drop table if exists {{ relation }} cascade
+{%- endmacro %}

dbt/include/global_project/macros/relations/table/rename.sql

@@ -0,0 +1,10 @@
+{% macro get_rename_table_sql(relation, new_name) %}
+    {{- adapter.dispatch('get_rename_table_sql', 'dbt')(relation, new_name) -}}
+{% endmacro %}
+
+
+{% macro default__get_rename_table_sql(relation, new_name) %}
+    {{ exceptions.raise_compiler_error(
+        "`get_rename_table_sql` has not been implemented for this adapter."
+    ) }}
+{% endmacro %}

dbt/include/global_project/macros/relations/table/replace.sql

@@ -0,0 +1,10 @@
+{% macro get_replace_table_sql(relation, sql) %}
+    {{- adapter.dispatch('get_replace_table_sql', 'dbt')(relation, sql) -}}
+{% endmacro %}
+
+
+{% macro default__get_replace_table_sql(relation, sql) %}
+    {{ exceptions.raise_compiler_error(
+        "`get_replace_table_sql` has not been implemented for this adapter."
+    ) }}
+{% endmacro %}

dbt/include/global_project/macros/relations/view/create.sql

@@ -0,0 +1,27 @@
+{% macro get_create_view_as_sql(relation, sql) -%}
+  {{ adapter.dispatch('get_create_view_as_sql', 'dbt')(relation, sql) }}
+{%- endmacro %}
+
+{% macro default__get_create_view_as_sql(relation, sql) -%}
+  {{ return(create_view_as(relation, sql)) }}
+{% endmacro %}
+
+
+/* {# keep logic under old name for backwards compatibility #} */
+{% macro create_view_as(relation, sql) -%}
+  {{ adapter.dispatch('create_view_as', 'dbt')(relation, sql) }}
+{%- endmacro %}
+
+{% macro default__create_view_as(relation, sql) -%}
+  {%- set sql_header = config.get('sql_header', none) -%}
+
+  {{ sql_header if sql_header is not none }}
+  create view {{ relation }}
+    {% set contract_config = config.get('contract') %}
+    {% if contract_config.enforced %}
+      {{ get_assert_columns_equivalent(sql) }}
+    {%- endif %}
+  as (
+    {{ sql }}
+  );
+{%- endmacro %}

dbt/include/global_project/macros/relations/view/drop.sql

@@ -0,0 +1,14 @@
+{# /*
+This was already implemented. Instead of creating a new macro that aligns with the standard,
+this was reused and the default was maintained. This gets called by `drop_relation`, which
+actually executes the drop, and `get_drop_sql`, which returns the template.
+*/ #}
+
+{% macro drop_view(relation) -%}
+    {{ return(adapter.dispatch('drop_view', 'dbt')(relation)) }}
+{%- endmacro %}
+
+
+{% macro default__drop_view(relation) -%}
+    drop view if exists {{ relation }} cascade
+{%- endmacro %}

dbt/include/global_project/macros/relations/view/rename.sql

@@ -0,0 +1,10 @@
+{% macro get_rename_view_sql(relation, new_name) %}
+    {{- adapter.dispatch('get_rename_view_sql', 'dbt')(relation, new_name) -}}
+{% endmacro %}
+
+
+{% macro default__get_rename_view_sql(relation, new_name) %}
+    {{ exceptions.raise_compiler_error(
+        "`get_rename_view_sql` has not been implemented for this adapter."
+    ) }}
+{% endmacro %}

dbt/include/global_project/macros/relations/view/replace.sql

@@ -0,0 +1,66 @@
+{% macro get_replace_view_sql(relation, sql) %}
+    {{- adapter.dispatch('get_replace_view_sql', 'dbt')(relation, sql) -}}
+{% endmacro %}
+
+
+{% macro default__get_replace_view_sql(relation, sql) %}
+    {{ exceptions.raise_compiler_error(
+        "`get_replace_view_sql` has not been implemented for this adapter."
+    ) }}
+{% endmacro %}
+
+
+/* {#
+       Core materialization implementation. BigQuery and Snowflake are similar
+       because both can use `create or replace view` where the resulting view's columns
+       are not necessarily the same as those of the existing view. On Redshift, this would
+       result in: ERROR:  cannot change number of columns in view
+
+       This implementation is superior to the create_temp, swap_with_existing, drop_old
+       paradigm because transactions don't run DDL queries atomically on Snowflake. By using
+       `create or replace view`, the materialization becomes atomic in nature.
+#} */
+
+{% macro create_or_replace_view() %}
+  {%- set identifier = model['alias'] -%}
+
+  {%- set old_relation = adapter.get_relation(database=database, schema=schema, identifier=identifier) -%}
+  {%- set exists_as_view = (old_relation is not none and old_relation.is_view) -%}
+
+  {%- set target_relation = api.Relation.create(
+      identifier=identifier, schema=schema, database=database,
+      type='view') -%}
+  {% set grant_config = config.get('grants') %}
+
+  {{ run_hooks(pre_hooks) }}
+
+  -- If there's a table with the same name and we weren't told to full refresh,
+  -- that's an error. If we were told to full refresh, drop it. This behavior differs
+  -- for Snowflake and BigQuery, so multiple dispatch is used.
+  {%- if old_relation is not none and old_relation.is_table -%}
+    {{ handle_existing_table(should_full_refresh(), old_relation) }}
+  {%- endif -%}
+
+  -- build model
+  {% call statement('main') -%}
+    {{ get_create_view_as_sql(target_relation, sql) }}
+  {%- endcall %}
+
+  {% set should_revoke = should_revoke(exists_as_view, full_refresh_mode=True) %}
+  {% do apply_grants(target_relation, grant_config, should_revoke=should_revoke) %}
+
+  {{ run_hooks(post_hooks) }}
+
+  {{ return({'relations': [target_relation]}) }}
+
+{% endmacro %}
+
+
+{% macro handle_existing_table(full_refresh, old_relation) %}
+    {{ adapter.dispatch('handle_existing_table', 'dbt')(full_refresh, old_relation) }}
+{% endmacro %}
+
+{% macro default__handle_existing_table(full_refresh, old_relation) %}
+    {{ log("Dropping relation " ~ old_relation ~ " because it is of type " ~ old_relation.type) }}
+    {{ adapter.drop_relation(old_relation) }}
+{% endmacro %}

dbt/include/global_project/macros/utils/any_value.sql

@@ -0,0 +1,9 @@
+{% macro any_value(expression) -%}
+    {{ return(adapter.dispatch('any_value', 'dbt') (expression)) }}
+{% endmacro %}
+
+{% macro default__any_value(expression) -%}
+
+    any_value({{ expression }})
+
+{%- endmacro %}