dbt-adapters 1.22.2__py3-none-any.whl

dbt/include/global_project/macros/materializations/tests/helpers.sql

@@ -0,0 +1,44 @@
+{% macro get_test_sql(main_sql, fail_calc, warn_if, error_if, limit) -%}
+  {{ adapter.dispatch('get_test_sql', 'dbt')(main_sql, fail_calc, warn_if, error_if, limit) }}
+{%- endmacro %}
+
+{% macro default__get_test_sql(main_sql, fail_calc, warn_if, error_if, limit) -%}
+    select
+      {{ fail_calc }} as failures,
+      {{ fail_calc }} {{ warn_if }} as should_warn,
+      {{ fail_calc }} {{ error_if }} as should_error
+    from (
+      {{ main_sql }}
+      {{ "limit " ~ limit if limit != none }}
+    ) dbt_internal_test
+{%- endmacro %}
+
+
+
+
+{% macro get_unit_test_sql(main_sql, expected_fixture_sql, expected_column_names) -%}
+  {{ adapter.dispatch('get_unit_test_sql', 'dbt')(main_sql, expected_fixture_sql, expected_column_names) }}
+{%- endmacro %}
+
+{% macro default__get_unit_test_sql(main_sql, expected_fixture_sql, expected_column_names) -%}
+-- Build actual result given inputs
+with dbt_internal_unit_test_actual as (
+  select
+    {% for expected_column_name in expected_column_names %}{{expected_column_name}}{% if not loop.last -%},{% endif %}{%- endfor -%}, {{ dbt.string_literal("actual") }} as {{ adapter.quote("actual_or_expected") }}
+  from (
+    {{ main_sql }}
+  ) _dbt_internal_unit_test_actual
+),
+-- Build expected result
+dbt_internal_unit_test_expected as (
+  select
+    {% for expected_column_name in expected_column_names %}{{expected_column_name}}{% if not loop.last -%}, {% endif %}{%- endfor -%}, {{ dbt.string_literal("expected") }} as {{ adapter.quote("actual_or_expected") }}
+  from (
+    {{ expected_fixture_sql }}
+  ) _dbt_internal_unit_test_expected
+)
+-- Union actual and expected results
+select * from dbt_internal_unit_test_actual
+union all
+select * from dbt_internal_unit_test_expected
+{%- endmacro %}

dbt/include/global_project/macros/materializations/tests/test.sql

@@ -0,0 +1,66 @@
+{%- materialization test, default -%}
+
+  {% set relations = [] %}
+  {% set limit = config.get('limit') %}
+
+  {% set sql_with_limit %}
+    {{ get_limit_subquery_sql(sql, limit) }}
+  {% endset %}
+
+  {% if should_store_failures() %}
+
+    {% set identifier = model['alias'] %}
+    {% set old_relation = adapter.get_relation(database=database, schema=schema, identifier=identifier) %}
+
+    {% set store_failures_as = config.get('store_failures_as') %}
+    -- if `--store-failures` is invoked via command line and `store_failures_as` is not set,
+    -- config.get('store_failures_as', 'table') returns None, not 'table'
+    {% if store_failures_as == none %}{% set store_failures_as = 'table' %}{% endif %}
+    {% if store_failures_as not in ['table', 'view'] %}
+        {{ exceptions.raise_compiler_error(
+            "'" ~ store_failures_as ~ "' is not a valid value for `store_failures_as`. "
+            "Accepted values are: ['ephemeral', 'table', 'view']"
+        ) }}
+    {% endif %}
+
+    {% set target_relation = api.Relation.create(
+        identifier=identifier, schema=schema, database=database, type=store_failures_as) -%} %}
+
+    {% if old_relation %}
+        {% do adapter.drop_relation(old_relation) %}
+    {% endif %}
+
+    {% call statement(auto_begin=True) %}
+        {{ get_create_sql(target_relation, sql_with_limit) }}
+    {% endcall %}
+
+    {% do relations.append(target_relation) %}
+
+    {# Since the test failures have already been saved to the database, reuse that result rather than querying again #}
+    {% set main_sql %}
+        select *
+        from {{ target_relation }}
+    {% endset %}
+
+    {{ adapter.commit() }}
+
+  {% else %}
+
+      {% set main_sql = sql_with_limit %}
+
+  {% endif %}
+
+  {% set fail_calc = config.get('fail_calc') %}
+  {% set warn_if = config.get('warn_if') %}
+  {% set error_if = config.get('error_if') %}
+
+  {% call statement('main', fetch_result=True) -%}
+
+    {# The limit has already been included above, and we do not want to duplicate it again. We also want to be safe for macro overrides treating `limit` as a required parameter. #}
+    {{ get_test_sql(main_sql, fail_calc, warn_if, error_if, limit=none)}}
+
+  {%- endcall %}
+
+  {{ return({'relations': relations}) }}
+
+{%- endmaterialization -%}

dbt/include/global_project/macros/materializations/tests/unit.sql

@@ -0,0 +1,40 @@
+{%- materialization unit, default -%}
+
+  {% set relations = [] %}
+
+  {% set expected_rows = config.get('expected_rows') %}
+  {% set expected_sql = config.get('expected_sql') %}
+  {% set tested_expected_column_names = expected_rows[0].keys() if (expected_rows | length ) > 0 else get_columns_in_query(sql) %}
+
+  {%- set target_relation = this.incorporate(type='table') -%}
+  {%- set temp_relation = make_temp_relation(target_relation)-%}
+  {% do run_query(get_create_table_as_sql(True, temp_relation, get_empty_subquery_sql(sql))) %}
+  {%- set columns_in_relation = adapter.get_columns_in_relation(temp_relation) -%}
+  {%- set column_name_to_data_types = {} -%}
+  {%- set column_name_to_quoted = {} -%}
+  {%- for column in columns_in_relation -%}
+  {%-   do column_name_to_data_types.update({column.name|lower: column.data_type}) -%}
+  {%-   do column_name_to_quoted.update({column.name|lower: column.quoted}) -%}
+  {%- endfor -%}
+
+  {%- set expected_column_names_quoted = [] -%}
+  {%- for column_name in tested_expected_column_names -%}
+  {%-   do expected_column_names_quoted.append(column_name_to_quoted[column_name|lower]) -%}
+  {%- endfor -%}
+
+  {% if not expected_sql %}
+  {%   set expected_sql = get_expected_sql(expected_rows, column_name_to_data_types, column_name_to_quoted) %}
+  {% endif %}
+  {% set unit_test_sql = get_unit_test_sql(sql, expected_sql, expected_column_names_quoted) %}
+
+  {% call statement('main', fetch_result=True) -%}
+
+    {{ unit_test_sql }}
+
+  {%- endcall %}
+
+  {% do adapter.drop_relation(temp_relation) %}
+
+  {{ return({'relations': relations}) }}
+
+{%- endmaterialization -%}

dbt/include/global_project/macros/materializations/tests/where_subquery.sql

@@ -0,0 +1,15 @@
+{% macro get_where_subquery(relation) -%}
+    {% do return(adapter.dispatch('get_where_subquery', 'dbt')(relation)) %}
+{%- endmacro %}
+
+{% macro default__get_where_subquery(relation) -%}
+    {% set where = config.get('where', '') %}
+    {% if where %}
+        {%- set filtered -%}
+            (select * from {{ relation }} where {{ where }}) dbt_subquery
+        {%- endset -%}
+        {% do return(filtered) %}
+    {%- else -%}
+        {% do return(relation) %}
+    {%- endif -%}
+{%- endmacro %}

dbt/include/global_project/macros/python_model/python.sql

@@ -0,0 +1,114 @@
+{% macro resolve_model_name(input_model_name) %}
+    {{ return(adapter.dispatch('resolve_model_name', 'dbt')(input_model_name)) }}
+{% endmacro %}
+
+{%- macro default__resolve_model_name(input_model_name) -%}
+    {{  input_model_name | string | replace('"', '\"') }}
+{%- endmacro -%}
+
+{% macro build_ref_function(model) %}
+
+    {%- set ref_dict = {} -%}
+    {%- for _ref in model.refs -%}
+        {% set _ref_args = [_ref.get('package'), _ref['name']] if _ref.get('package') else [_ref['name'],] %}
+        {%- set resolved = ref(*_ref_args, v=_ref.get('version')) -%}
+
+        {#
+            We want to get the string of the returned relation by calling .render() in order to skip sample/empty
+            mode rendering logic. However, people override the default ref macro, and often return a string instead
+            of a relation (like the ref macro does by default). Thus, to make sure we dont blow things up, we have
+            to ensure the resolved relation has a .render() method.
+        #}
+        {%- if resolved.render is defined and resolved.render is callable -%}
+            {%- set resolved = resolved.render() -%}
+        {%- endif -%}
+
+        {%- if _ref.get('version') -%}
+            {% do _ref_args.extend(["v" ~ _ref['version']]) %}
+        {%- endif -%}
+       {%- do ref_dict.update({_ref_args | join('.'): resolve_model_name(resolved)}) -%}
+    {%- endfor -%}
+
+def ref(*args, **kwargs):
+    refs = {{ ref_dict | tojson }}
+    key = '.'.join(args)
+    version = kwargs.get("v") or kwargs.get("version")
+    if version:
+        key += f".v{version}"
+    dbt_load_df_function = kwargs.get("dbt_load_df_function")
+    return dbt_load_df_function(refs[key])
+
+{% endmacro %}
+
+{% macro build_source_function(model) %}
+
+    {%- set source_dict = {} -%}
+    {%- for _source in model.sources -%}
+        {%- set resolved = source(*_source) -%}
+        {%- do source_dict.update({_source | join('.'): resolve_model_name(resolved)}) -%}
+    {%- endfor -%}
+
+def source(*args, dbt_load_df_function):
+    sources = {{ source_dict | tojson }}
+    key = '.'.join(args)
+    return dbt_load_df_function(sources[key])
+
+{% endmacro %}
+
+{% macro build_config_dict(model) %}
+    {%- set config_dict = {} -%}
+    {% set config_dbt_used = zip(model.config.config_keys_used, model.config.config_keys_defaults) | list %}
+    {%- for key, default in config_dbt_used -%}
+        {# weird type testing with enum, would be much easier to write this logic in Python! #}
+        {%- if key == "language" -%}
+          {%- set value = "python" -%}
+        {%- endif -%}
+        {%- set value = model.config.get(key, default) -%}
+        {%- do config_dict.update({key: value}) -%}
+    {%- endfor -%}
+config_dict = {{ config_dict }}
+{% endmacro %}
+
+{% macro py_script_postfix(model) %}
+# This part is user provided model code
+# you will need to copy the next section to run the code
+# COMMAND ----------
+# this part is dbt logic for get ref work, do not modify
+
+{{ build_ref_function(model ) }}
+{{ build_source_function(model ) }}
+{{ build_config_dict(model) }}
+
+class config:
+    def __init__(self, *args, **kwargs):
+        pass
+
+    @staticmethod
+    def get(key, default=None):
+        return config_dict.get(key, default)
+
+class this:
+    """dbt.this() or dbt.this.identifier"""
+    database = "{{ this.database }}"
+    schema = "{{ this.schema }}"
+    identifier = "{{ this.identifier }}"
+    {% set this_relation_name = resolve_model_name(this) %}
+    def __repr__(self):
+        return '{{ this_relation_name  }}'
+
+
+class dbtObj:
+    def __init__(self, load_df_function) -> None:
+        self.source = lambda *args: source(*args, dbt_load_df_function=load_df_function)
+        self.ref = lambda *args, **kwargs: ref(*args, **kwargs, dbt_load_df_function=load_df_function)
+        self.config = config
+        self.this = this()
+        self.is_incremental = {{ is_incremental() }}
+
+# COMMAND ----------
+{{py_script_comment()}}
+{% endmacro %}
+
+{#-- entry point for add instuctions for running compiled_code --#}
+{%macro py_script_comment()%}
+{%endmacro%}

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.render() }} 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) -%}
+    {{- adapter.dispatch('drop_materialized_view', 'dbt')(relation) -}}
+{%- endmacro %}
+
+
+{% macro default__drop_materialized_view(relation) -%}
+    drop materialized view if exists {{ relation.render() }} 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.render() }} 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 -%}