dbt-firebolt 1.9.0__py3-none-any.whl → 1.9.1__py3-none-any.whl

dbt/include/firebolt/macros/materializations/models/incremental/incremental.sql

@@ -1,131 +0,0 @@
-{% macro dbt_firebolt_get_tmp_relation_type(strategy) %}
-  {#
-    Determine whether to use a temporary view or a table based on
-    specified strategy and config. Users can override the behaviour
-    by setting tmp_replation_type. Default is to use a view (more efficient).
-
-    Arguments:
-      strategy: incremental strategy from config. e.g. "append"
-  #}
-  {%- set tmp_relation_type = config.get('tmp_relation_type') -%}
-
-  {% if tmp_relation_type == "table" %}
-    {{ return("table") }}
-  {% elif tmp_relation_type == "view" %}
-    {{ return("view") }}
-  {% elif strategy in ("default", "append", "insert_overwrite") %}
-    {{ return("view") }}
-  {% else %}
-    {{ return("table") }}
-  {% endif %}
-{% endmacro %}
-
-{% materialization incremental, adapter='firebolt' -%}
-  {#
-  Incremental implementation. Actual strategy SQL is determined
-  outside this materialization, in strategies.sql.
-
-  This function works by first creating a view, `new_records`, of type `BaseRelation`,
-  then using a CTE defined in the project model to populate `new_records` with
-  any records that ought to be inserted into the original table (views aren't currently
-  supported), `existing`, using an INSERT. This process is agnostic to the incremental
-  strategy actually used: the specific INSERT is defined in `strategies.sql`.
-
-  Note that all new relations must first be instantiated as BaseRelation objects,
-  and that those objects are used to create and query actual relations in the DB.
-  Care must be taken to correctly define each BaseRelation as either a view or
-  a table, lest subsequent operations on the relations (be the they objects or
-  the DB tables the objects abstract) fail.
-  #}
-
-  {% set unique_key = config.get('unique_key') %}
-
-  {% set grant_config = config.get('grants') %}
-
-  {%- set strategy = config.get('incremental_strategy') -%}
-  {%- if is_incremental() and strategy is none -%}
-    {{ log('Model %s is set to incremental, but no incremental strategy is set. '
-           'Defaulting to append' % this, True) }}
-    {%- set strategy = 'append' -%}
-  {%- endif -%}
-  {# In following lines:
-
-     `target` is just a dbt `BaseRelation` object, not a DB table.
-
-     We're only retrieving `existing` to check for existence; `load_relation()`
-     returns a `BaseRelation` with the dictionary values of any relations that exist
-     in dbt's cache that share the identifier of the passed relation. If none
-     exist, returns None. Note that this does *not* create a table in the DB.
-
-     `target` is a relation with all the same fields as `existing`, but guaranteed
-     to be an actual `BaseRelation` object. #}
-  {%- set target = this.incorporate(type='table') -%}
-  {%- set existing = load_relation(this) -%}
-  {%- set tmp_relation_type = dbt_firebolt_get_tmp_relation_type(strategy) -%}
-  {%- set new_records = make_temp_relation(target) -%}
-  {{ drop_relation_if_exists(new_records) }}
-  {%- set new_records = new_records.incorporate(type=tmp_relation_type) -%}
-  {%- set on_schema_change = incremental_validate_on_schema_change(
-                                config.get('on_schema_change'),
-                                default='ignore') -%}
-
-  -- `BEGIN` happens here:
-  {{ run_hooks(pre_hooks, inside_transaction=True) }}
-  {%- set partition_by = config.get('partition_by') -%}
-  {# First check whether we want to full refresh for existing view or config reasons. #}
-  {%- if strategy == 'insert_overwrite' and not partition_by -%}
-    {% do exceptions.raise_compiler_error('`insert_overwrite` is specified for model %s, '
-                                          'but `partition_by` is not. `insert_overwrite` '
-                                          'requires a partition.' % (target)) %}
-  {%- endif -%}
-  {%- set do_full_refresh = (should_full_refresh()
-                             or existing.is_view) %}
-  {% if existing is none %}
-    {%- set build_sql = create_table_as(False, target, sql) -%}
-  {%- elif do_full_refresh -%}
-    {{ drop_relation_if_exists(existing) }}
-    {%- set build_sql = create_table_as(False, target, sql) -%}
-  {%- else -%}
-    {# Actually do the incremental query here. #}
-    {# Instantiate new objects in dbt's internal list. Have to
-       run this query so dbt can query the DB to get the columns in
-       new_records. #}
-    {%- if tmp_relation_type=='view' -%}
-      {%- do run_query(create_view_as(new_records, sql)) -%}
-    {%- else -%}
-      {%- do run_query(create_table_as(True, new_records, sql)) -%}
-    {%- endif -%}
-    {# All errors involving schema changes are dealt with in `process_schema_changes`. #}
-    {%- set dest_columns = process_schema_changes(on_schema_change,
-                                                  new_records,
-                                                  existing) -%}
-    {%- set incremental_predicates = config.get('predicates', none) or config.get('incremental_predicates', none) -%}
-    {%- set build_sql = get_incremental_sql(strategy,
-                                            new_records,
-                                            target,
-                                            unique_key,
-                                            dest_columns,
-                                            incremental_predicates) -%}
-  {%- endif -%}
-  {%- call statement("main") -%}
-    {{ build_sql }}
-  {%- endcall -%}
-
-  {% set should_revoke = should_revoke(existing_relation, full_refresh_mode) %}
-  {% do apply_grants(target_relation, grant_config, should_revoke) %}
-
-  {# Todo: figure out what persist_docs and create_indexes do. #}
-  {%- do persist_docs(target, model) -%}
-  {%- if existing is none
-      or existing.is_view
-      or should_full_refresh() -%}
-  {%- do create_indexes(target) -%}
-  {%- endif %}
-
-  {{ drop_relation_if_exists(new_records) }}
-
-  {{ run_hooks(post_hooks, inside_transaction=True) }}
-
-  {{ return({'relations': [target]}) }}
-
-{%- endmaterialization %}

dbt/include/firebolt/macros/materializations/models/incremental/is_incremental.sql

@@ -1,14 +0,0 @@
-{% macro is_incremental() %}
-    {#- Return True if model is incremental, otherwise False. -#}
-    {% if not execute %}
-        {{ return(False) }}
-    {% else %}
-        {% set relation = adapter.get_relation(this.database,
-                                               this.schema,
-                                               this.table) %}
-        {{ return(relation is not none
-                  and relation.type == 'table'
-                  and model.config.materialized == 'incremental'
-                  and not should_full_refresh()) }}
-    {% endif %}
-{% endmacro %}

dbt/include/firebolt/macros/materializations/models/incremental/merge.sql

@@ -1,38 +0,0 @@
-{% macro firebolt__get_delete_insert_merge_sql(target, source, unique_key, dest_columns, incremental_predicates) -%}
-
-    {%- set dest_cols_csv = get_quoted_csv(dest_columns | map(attribute="name")) -%}
-
-    {% if unique_key %}
-        {% if unique_key is sequence and unique_key is not string %}
-            delete from {{ target }}
-            where
-                ({{ get_quoted_csv(unique_key) }}) in (
-                    select {{ get_quoted_csv(unique_key) }}
-                    from {{ source }}
-                )
-                {% if incremental_predicates %}
-                    {% for predicate in incremental_predicates %}
-                        and {{ predicate }}
-                    {% endfor %}
-                {% endif %};
-        {% else %}
-            delete from {{ target }}
-            where (
-                {{ unique_key }}) in (
-                select ({{ unique_key }})
-                from {{ source }}
-            )
-            {%- if incremental_predicates %}
-                {% for predicate in incremental_predicates %}
-                    and {{ predicate }}
-                {% endfor %}
-            {%- endif -%};
-
-        {% endif %}
-    {% endif %}
-
-    insert into {{ target }} ({{ dest_cols_csv }})
-    select {{ dest_cols_csv }}
-    from {{ source }}
-
-{%- endmacro %}

dbt/include/firebolt/macros/materializations/models/incremental/on_schema_change.sql

@@ -1,90 +0,0 @@
-{% macro incremental_validate_on_schema_change(on_schema_change, default='ignore') %}
-  {#
-  Ensure that the value of `on_schema_change` in dbt_project models is valid.
-  Firebolt doesnt currently support `sync_all_columns`, so this is excluded
-  from valid columns.
-  #}
-  {% if on_schema_change == 'sync_all_columns' %}
-    {% do exceptions.raise_compiler_error(
-              'Firebolt does not support the on_schema_change value "sync_all_columns."') %}
-    {{ return(default) }}
-  {% else %}
-    {{ return(on_schema_change) }}
-  {% endif %}
-{% endmacro %}
-
-
-{% macro check_for_schema_changes(source_relation, target_relation) %}
-  {#
-  Return a dict = {
-     'schema_changed': schema_changed,
-     'source_not_in_target': source_not_in_target (List[FireboltColumn]),
-     'target_not_in_source': target_not_in_source (List[FireboltColumn]),
-     'source_columns': source_columns (List[FireboltColumn]),
-     'target_columns': target_columns (List[FireboltColumn]),
-     'new_target_types': new_target_types,
-     'common_columns': common_colums
-  }
-  Args:
-      source_relation: dbt Relation
-      target_relation: dbt Relation
-  #}
-  {%- set schema_changed = False -%}
-  {%- set source_columns = adapter.get_columns_in_relation(source_relation) -%}
-  {%- set target_columns = adapter.get_columns_in_relation(target_relation) -%}
-  {%- set source_not_in_target = diff_columns(source_columns, target_columns) -%}
-  {%- set target_not_in_source = diff_columns(target_columns, source_columns) -%}
-  {%- set new_target_types = diff_column_data_types(source_columns, target_columns) -%}
-  {%- set common_columns = intersect_columns(source_columns, target_columns) -%}
-  {% if source_not_in_target != [] %}
-    {%- set schema_changed = True -%}
-  {% elif target_not_in_source != [] or new_target_types != [] %}
-    {%- set schema_changed = True -%}
-  {% elif new_target_types != [] %}
-    {%- set schema_changed = True -%}
-  {% endif %}
-  {% set changes_dict = {
-    'schema_changed': schema_changed,
-    'source_not_in_target': source_not_in_target,
-    'target_not_in_source': target_not_in_source,
-    'source_columns': source_columns,
-    'target_columns': target_columns,
-    'new_target_types': new_target_types,
-    'common_columns': common_columns
-  } %}
-  {{ return(changes_dict) }}
-{% endmacro %}
-
-
-{% macro process_schema_changes(on_schema_change, source_relation, target_relation) %}
-  {#
-  Check for schema changes. Error out if appropriate, else return the list of columns
-  that will be transferred from source to target, i.e. the intersection of the columns.
-  #}
-  {% if on_schema_change == 'sync_all_columns' %}
-     {% do exceptions.raise_compiler_error(
-             'Firebolt does not allow an `on_schema_change` value of `sync_all_columns`.') %}
-  {% endif %}
-  {% set schema_changes_dict = check_for_schema_changes(source_relation, target_relation) %}
-  {% if schema_changes_dict['schema_changed'] %}
-    {% if on_schema_change == 'fail' %}
-      {% do exceptions.raise_compiler_error(
-          'A schema change was detected and `on_schema_change` was set to "fail".') %}
-    {% else %}
-      {% set fail_msg %}
-          Schema changes detected on this incremental!
-          Either revert the change or run the model with the --full-refresh flag
-          on the command line to recreate the model with the new schema definition.
-          Running with the --full-refresh flag drops and recreates the database object.
-
-          Additional troubleshooting context:
-              Source columns not in target: {{ schema_changes_dict['source_not_in_target'] }}
-              Target columns not in source: {{ schema_changes_dict['target_not_in_source'] }}
-              New column types: {{ schema_changes_dict['new_target_types'] }}
-      {% endset %}
-
-      {% do exceptions.raise_compiler_error(fail_msg) %}
-    {% endif %}
-  {% endif %}
-  {{ return(schema_changes_dict['common_columns']) }}
-{% endmacro %}

dbt/include/firebolt/macros/materializations/models/incremental/strategies.sql

@@ -1,132 +0,0 @@
-{% macro get_incremental_sql(strategy, source, target, unique_key, dest_columns, incremental_predicates) %}
-  {#
-  Retrieve appropriate SQL for whichever incremental strategy is given.
-  Args:
-    strategy: string, which incremental strategy is in to be used.
-    source: string, table from which queried results will be taken.
-    target: string, table into which results will be inserted.
-    unique_key: string, only as a placeholder for future use
-    dest_columns: List[string] of the names of the columns which data will be
-      inserted into.
-  #}
-  {%- if strategy == 'append' -%}
-    {#- Only insert new records into existing table, relying on user to manage
-       merges. -#}
-    {{ get_insert_only_sql(source, target, dest_columns) }}
-  {%- elif strategy == 'insert_overwrite' -%}
-    {#- Insert new data. If any data is duplicate, drop partition containing
-       previous data and insert new. -#}
-    {{ get_insert_overwrite_sql(source, target, dest_columns) }}
-  {%- elif strategy == 'delete+insert' -%}
-    {% do return(get_delete_insert_merge_sql(target, source, unique_key, dest_columns, incremental_predicates)) %}
-  {%- elif strategy is not none -%}
-    {% do exceptions.raise_compiler_error('Model %s has incremental strategy %s '
-                                          'specified, but that strategy is not '
-                                          'supported.' % (target, strategy)) %}
-  {% else %}
-    {{ exceptions.raise_compiler_error('No incremental strategy was specified '
-                                       'for model %s.' % (target)) }}
-  {%- endif -%}
-{% endmacro %}
-
-
-{% macro get_insert_only_sql(source, target, dest_columns) -%}
-  {%- set dest_cols_csv = get_quoted_csv(dest_columns | map(attribute="name")) %}
-
-  INSERT INTO {{ target }} ({{ dest_cols_csv }})
-  SELECT {{ dest_cols_csv }}
-  FROM {{ source }}
-{%- endmacro %}
-
-
-{% macro get_insert_overwrite_sql(source, target, dest_columns) %}
-  {#
-  Compile SQL to drop correct partitions in target and insert from source.
-  Args:
-    source: Relation from which queried results will be taken.
-    target: Relation into which results will be inserted.
-    dest_columns: list of the names of the columns which data will be
-      inserted into.
-  #}
-  {%- set partition_cols = config.get('partition_by') -%}
-  {%- set partition_vals = config.get('partitions') -%}
-  {#- Get values of partition columns for each row that will be inserted from
-     source. For each of those rows we'll drop the partition in the target. Use
-     the partition values provided in the confg block. _If_ no partition values
-     are provided, query the DB to find all partition values in the source table
-     and drop them. To match format of SQL query results, we convert each sublist
-     to a string. -#}
-  {%- if partition_vals -%}
-    {# Partition vals are set in config. #}
-    {{ drop_partitions_sql(target, partition_vals, True) }}
-  {%- else -%} {# No partition values were set in config. #}
-    {%- call statement('get_partition_cols', fetch_result=True) %}
-
-      SELECT
-      {% if partition_cols is iterable and partition_cols is not string -%}
-        DISTINCT {{ partition_cols | join(', ') }}
-      {%- else -%}
-        DISTINCT {{ partition_cols }}
-      {%- endif %}
-      FROM {{ source }}
-    {%- endcall -%}
-    {%- set partition_vals = load_result('get_partition_cols').table.rows -%}
-    {{ drop_partitions_sql(target, partition_vals, partition_cols, False) }}
-  {%- endif -%}
-  {%- set dest_columns = adapter.get_columns_in_relation(target) -%}
-  {%- set dest_cols_csv = dest_columns | map(attribute='quoted') | join(', ') -%}
-
-  {{ get_insert_only_sql(source, target, dest_columns) }}
-{% endmacro %}
-
-
-{% macro drop_partitions_sql(relation,
-                             partition_vals,
-                             part_col_names,
-                             vals_set_in_config) %}
-  {#
-  Write SQL code to drop each partition in `partition_vals`.
-  Args:
-    relation: a relation whose name will be used for `DROP PARTITION` queries.
-    partition_vals: a list of strings, each of which begins with a '['' and
-      ends with a ']', as such: '[val1, val2]', and each of which represents
-      a partition to be dropped.
-    part_col_names: a list of string, the names of the partition columns.
-    vals_set_in_config: a boolean used to determine how to treat `partition_vals`,
-      whether as a list of strings or as a list of Agate rows.
-  #}
-  {%- for vals in partition_vals -%}
-    {%- set vals -%}
-      {%- if vals is iterable and vals is not string -%}
-        {%- if vals_set_in_config -%}
-          {# `vals` is a list of strings. #}
-          {{ vals | string() | trim() | slice(1, -1) }}
-        {%- else -%}
-          {# `vals` is a list of Agate rows. #}
-          {%- if 1 == (vals | length) -%}
-            {#- There's a weird behavior where, if dbt
-                queries for only a single (text?) field `join()` removes the
-                qoutes on the resulting string. So I have to do a little bit
-                of extra work. -#}
-            '{{ vals | join(', ') }}'
-          {%- else -%}
-            '{{ vals | join("', '") }}'
-          {%- endif -%}
-        {%- endif -%}
-      {%- else -%}
-        {{ vals }}
-      {%- endif -%}
-    {%- endset -%}
-  {%- set vals = vals.strip() -%}
-  {%- if vals.startswith("'[") -%}
-    {#- If a single row is returned, but has  multiple values. -#}
-    {%- set vals = vals[2:-2] -%}
-  {%- endif -%}
-  {#- At this point, vals is a simple string of values separated by commas. -#}
-  {%- set col_types = adapter.get_columns_in_relation(relation) -%}
-  {%- set vals = adapter.annotate_date_columns_for_partitions(vals,
-                                                              part_col_names,
-                                                              col_types) %}
-  ALTER TABLE {{relation}} DROP PARTITION {{ vals.strip() }};
-  {%- endfor -%}
-{% endmacro %}

dbt/include/firebolt/macros/materializations/seed.sql

@@ -1,42 +0,0 @@
-{% macro firebolt__get_binding_char() %}
-  {# Override the wildcard character in prepared SQL statements. #}
-  {{ return('?') }}
-{% endmacro %}
-
-
-{% macro firebolt__create_csv_table(model, agate_table) %}
-    {%- set column_override = model['config'].get('column_types', {}) -%}
-    {%- set quote_seed_column = model['config'].get('quote_columns', None) -%}
-    {% set sql %}
-
-      CREATE DIMENSION TABLE IF NOT EXISTS {{ this.render() }} (
-          {%- for col_name in agate_table.column_names -%}
-              {%- set inferred_type = adapter.convert_type(agate_table, loop.index0) -%}
-              {%- set type = column_override.get(col_name, inferred_type) -%}
-              {%- set column_name = (col_name | string) -%}
-              {{ adapter.quote_seed_column(column_name, quote_seed_column) }} {{ type }}
-              {%- if not loop.last -%}, {%- endif -%}
-          {%- endfor -%}
-      )
-    {% endset %}
-    {% call statement('_') %}
-        {{ sql }}
-    {%- endcall %}
-    {{ return(sql) }}
-{% endmacro %}
-
-
-{# TODO: Make sure this is going to run correctly, or delete it. #}
-{% macro firebolt__reset_csv_table(model,
-                                   full_refresh,
-                                   old_relation,
-                                   agate_table) %}
-    {% set sql = "" %}
-    {% if full_refresh %}
-        {{ adapter.drop_relation(old_relation) }}
-    {% else %}
-        {{ adapter.truncate_relation(old_relation) }}
-    {% endif %}
-    {% set sql = create_csv_table(model, agate_table) %}
-    {{ return(sql) }}
-{% endmacro %}

dbt/include/firebolt/macros/materializations/snapshot_merge.sql

@@ -1,19 +0,0 @@
-{% macro firebolt__snapshot_merge_sql(target, source, insert_cols) -%}
-    {%- set insert_cols_csv = insert_cols | join(', ') -%}
-
-    UPDATE {{ target.render() }} AS DBT_INTERNAL_DEST
-    SET dbt_valid_to = DBT_INTERNAL_SOURCE.dbt_valid_to
-    FROM {{ source }} AS DBT_INTERNAL_SOURCE
-    WHERE DBT_INTERNAL_SOURCE.dbt_scd_id = DBT_INTERNAL_DEST.dbt_scd_id
-    AND DBT_INTERNAL_DEST.dbt_valid_to IS NULL
-    AND DBT_INTERNAL_SOURCE.dbt_change_type IN ('update', 'delete');
-
-    INSERT INTO {{ target.render() }} ({{ insert_cols_csv }})
-    SELECT {{ insert_cols_csv }}
-    FROM {{ source }} AS DBT_INTERNAL_SOURCE
-    WHERE DBT_INTERNAL_SOURCE.dbt_scd_id NOT IN (
-        SELECT dbt_scd_id FROM {{ target.render() }}
-    )
-    AND DBT_INTERNAL_SOURCE.dbt_change_type = 'insert';
-
-{% endmacro %}

dbt/include/firebolt/macros/materializations/table.sql

@@ -1,40 +0,0 @@
-{% materialization table, adapter='firebolt' %}
-{# Note that a nearly identical materialization appears in table.sql. #}
-  {%- set identifier = model['alias'] -%} {# alias comes from where? #}
-
-  {# Temporary workaround to issue with adapter.get_relation() until
-     the following are resolved:
-     https://github.com/firebolt-db/dbt-firebolt/issues/11
-     https://github.com/dbt-labs/dbt-core/issues/4187
-     the hack is to always drop the view/table if it already exists rather than
-     checking the db first to see if it exists.
-   #}
-  {%- set target_relation = api.Relation.create(database=database,
-                                                schema=schema,
-                                                identifier=identifier,
-                                                type='table') -%}
-  {%- set target_relation_view = api.Relation.create(database=database,
-                                                     schema=schema,
-                                                     identifier=identifier,
-                                                     type='view') -%}
-
-  {%- set grant_config = config.get('grants') -%}
-
-  {{ run_hooks(pre_hooks) }}
-
-  {% do adapter.drop_relation(target_relation) %}
-  {% do adapter.drop_relation(target_relation_view) %}
-
-  -- build model
-  {% call statement('main') -%}
-    {{ create_table_as(False, target_relation, sql) }}
-  {%- endcall %}
-  {% do create_indexes(target_relation) %}
-  {{ run_hooks(post_hooks) }}
-
-  {% set should_revoke = should_revoke(old_relation, full_refresh_mode=True) %}
-  {% do apply_grants(target_relation, grant_config, should_revoke) %}
-
-  {% do persist_docs(target_relation, model) %}
-  {{ return({'relations': [target_relation]}) }}
-{% endmaterialization %}

dbt/include/firebolt/macros/materializations/test.sql

@@ -1,15 +0,0 @@
-{% macro firebolt__get_test_sql(main_sql, fail_calc, warn_if, error_if, limit) %}
-
-    SELECT
-      COALESCE(CAST({{ fail_calc }} AS INT), 0) AS failures,
-      CASE WHEN {{ fail_calc }} {{ warn_if }}
-        THEN 'true' ELSE 'false'
-      END AS should_warn,
-      CASE WHEN {{ fail_calc }} {{ error_if }}
-        THEN 'true' ELSE 'false'
-      END AS should_error
-    FROM (
-      {{ main_sql }}
-      {{ "LIMIT " ~ limit if limit is not none }}
-    ) dbt_internal_test
-{%- endmacro %}

dbt/include/firebolt/macros/materializations/view.sql

@@ -1,39 +0,0 @@
-{% materialization view, adapter='firebolt' %}
-{# Note that a nearly identical materialization appears
-   in table.sql #}
-  {%- set identifier = model['alias'] -%} {# alias comes from where? #}
-
-  {# Temporary workaround to issue with adapter.get_relation() until
-     the following are resolved:
-     https://github.com/firebolt-db/dbt-firebolt/issues/11
-     https://github.com/dbt-labs/dbt-core/issues/4187
-     the hack is to always drop the view/table if it already exists rather than
-     checking the db first to see if it exists.
-   #}
-  {%- set target_relation = api.Relation.create(database=database,
-                                                schema=schema,
-                                                identifier=identifier,
-                                                type='view') -%}
-  {%- set target_relation_table = api.Relation.create(database=database,
-                                                      schema=schema,
-                                                      identifier=identifier,
-                                                      type='table') -%}
-  {%- set grant_config = config.get('grants') -%}
-
-  {{ run_hooks(pre_hooks) }}
-
-  {% do adapter.drop_relation(target_relation) %}
-  {% do adapter.drop_relation(target_relation_table) %}
-
-  -- build model
-  {% call statement('main') -%}
-    {{ create_view_as(target_relation, sql) }}
-  {%- endcall %}
-  {{ run_hooks(post_hooks) }}
-
-  {% set should_revoke = should_revoke(old_relation, full_refresh_mode=True) %}
-  {% do apply_grants(target_relation, grant_config, should_revoke) %}
-
-  {% do persist_docs(target_relation, model) %}
-  {{ return({'relations': [target_relation]}) }}
-{% endmaterialization %}

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

@@ -1,11 +0,0 @@
-{% macro firebolt__get_alter_materialized_view_as_sql(
-    relation,
-    configuration_changes,
-    sql,
-    existing_relation,
-    backup_relation,
-    intermediate_relation
-) %}
-
-    {{ exceptions.raise_compiler_error("Firebolt does not support materialized views") }}
-{% endmacro %}

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

@@ -1,3 +0,0 @@
-{% macro firebolt__get_create_materialized_view_as_sql(relation, sql) %}
-    {{ exceptions.raise_compiler_error("Firebolt does not support materialized views") }}
-{% endmacro %}

dbt/include/firebolt/macros/relations/materialized_view/describe.sql

@@ -1,3 +0,0 @@
-{% macro redshift__describe_materialized_view(relation) %}
-    {{ exceptions.raise_compiler_error("Firebolt does not support materialized views") }}
-{% endmacro %}

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

@@ -1,3 +0,0 @@
-{% macro firebolt__drop_materialized_view(relation) %}
-    {{ exceptions.raise_compiler_error("Firebolt does not support materialized views") }}
-{% endmacro %}

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

@@ -1,3 +0,0 @@
-{% macro firebolt__refresh_materialized_view(relation) %}
-    {{ exceptions.raise_compiler_error("Firebolt does not support materialized views") }}
-{% endmacro %}