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

dbt/include/firebolt/macros/dbt_external_tables/create_external_table.sql

@@ -1,137 +0,0 @@
-{% macro firebolt__create_external_table(source_node) %}
-    {% if source_node.external.strategy == 'copy' %}
-        {{ firebolt__create_with_copy_from(source_node) }}
-    {% else %}
-        {{ firebolt__create_with_external_table(source_node) }}
-    {% endif %}
-{% endmacro %}
-
-{% macro firebolt__create_with_external_table(source_node) %}
-    {%- set external = source_node.external -%}
-    {%- if 'partitions' in external -%}
-        {%- set columns = adapter.make_field_partition_pairs(source_node.columns.values(),
-                                                             external.partitions) -%}
-    {%- else -%}
-        {%- set columns = adapter.make_field_partition_pairs(source_node.columns.values(),
-                                                             []) -%}
-    {%- endif -%}
-    {%- set credentials = external.credentials -%}
-    {# Leaving out "IF NOT EXISTS" because this should only be called by
-       if no DROP IF is necessary. #}
-    CREATE EXTERNAL TABLE {{source(source_node.source_name, source_node.name)}} (
-        {%- for column in columns -%}
-          {{ column }}
-          {{- ',' if not loop.last }}
-        {% endfor -%}
-    )
-    {% if external.url %} URL = '{{external.url}}' {%- endif %}
-    {%- if credentials and credentials.internal_role_arn %}
-        CREDENTIALS = (AWS_ROLE_ARN = '{{credentials.internal_role_arn}}'
-        {%- if credentials.external_role_id %}
-                       AWS_ROLE_EXTERNAL_ID = '{{credentials.external_role_id}}'
-        {%- endif -%}
-        )
-    {% elif credentials and credentials.aws_key_id %}
-        CREDENTIALS = (AWS_KEY_ID = '{{credentials.aws_key_id}}'
-                       AWS_SECRET_KEY = '{{credentials.aws_secret_key}}')
-    {%- endif %}
-    {%- if external.object_pattern -%} OBJECT_PATTERN = '{{external.object_pattern}}' {%- endif %}
-    {% if external.object_patterns -%}
-        OBJECT_PATTERN =
-            {%- for obj in external.object_patterns -%}
-                {{ obj }}
-                {{- ',' if not loop.last }}
-            {%- endfor %}
-    {%- endif %}
-    {%- if external.compression -%} COMPRESSION = {{external.compression}} {%- endif %}
-    TYPE = {{ external.type }}
-{% endmacro %}
-
-{% macro firebolt__create_with_copy_from(source_node) %}
-    {# COPY FROM is only available in Firebolt 2.0. #}
-    {%- set external = source_node.external -%}
-    {%- set credentials = external.credentials -%}
-    {%- set options = external.options -%}
-    {%- set csv_options = options.csv_options -%}
-    {%- set error_file_credentials = options.error_file_credentials -%}
-
-    {# There are no partitions, but this formats the columns correctly. #}
-    {%- if 'partitions' in external -%}
-        {%- set columns = adapter.make_field_partition_pairs(source_node.columns.values(),
-                                                             external.partitions) -%}
-    {%- else -%}
-        {%- set columns = adapter.make_field_partition_pairs(source_node.columns.values(),
-                                                             []) -%}
-    {%- endif -%}
-    COPY INTO {{source(source_node.source_name, source_node.name)}}
-    {%- if columns and columns | length > 0 %}
-    (
-        {%- for column in columns -%}
-          {{ column.name }}
-          {%- if column.default %} DEFAULT {{ column.default }}{% endif %}
-          {%- if column.source_column_name %} {{ '$' ~ loop.index0 }}{% endif %}
-          {{- ',' if not loop.last }}
-        {%- endfor -%}
-    )
-    {%- endif %}
-    FROM '{{external.url}}'
-    {%- if options %}
-        WITH
-        {%- if options.object_pattern %}
-            PATTERN = '{{options.object_pattern}}'
-        {%- endif %}
-        {%- if options.type %}
-            TYPE = {{ options.type }}
-        {%- endif %}
-        {%- if options.auto_create %}
-            AUTO_CREATE = {{ options.auto_create | upper }}
-        {%- endif %}
-        {%- if options.allow_column_mismatch %}
-            ALLOW_COLUMN_MISMATCH = {{ options.allow_column_mismatch | upper }}
-        {%- endif %}
-        {%- if options.error_file %}
-            ERROR_FILE = '{{ options.error_file }}'
-        {%- endif %}
-        {%- if error_file_credentials %}
-            ERROR_FILE_CREDENTIALS = (AWS_KEY_ID = '{{ error_file_credentials.aws_key_id }}' AWS_SECRET_KEY = '{{ error_file_credentials.aws_secret_key }}')
-        {%- endif %}
-        {%- if options.max_errors_per_file %}
-            MAX_ERRORS_PER_FILE = {{ options.max_errors_per_file }}
-        {%- endif %}
-        {%- if csv_options %}
-            {%- if csv_options.header %}
-                HEADER = {{ csv_options.header | upper }}
-            {%- endif %}
-            {%- if csv_options.delimiter %}
-                DELIMITER = '{{ csv_options.delimiter }}'
-            {%- endif %}
-            {%- if csv_options.newline %}
-                NEWLINE = '{{ csv_options.newline }}'
-            {%- endif %}
-            {%- if csv_options.quote %}
-                QUOTE = {{ csv_options.quote }}
-            {%- endif %}
-            {%- if csv_options.escape %}
-                ESCAPE = '{{ csv_options.escape }}'
-            {%- endif %}
-            {%- if csv_options.null_string %}
-                NULL_STRING = '{{ csv_options.null_string }}'
-            {%- endif %}
-            {%- if csv_options.empty_field_as_null %}
-                EMPTY_FIELD_AS_NULL = {{ csv_options.empty_field_as_null | upper }}
-            {%- endif %}
-            {%- if csv_options.skip_blank_lines %}
-                SKIP_BLANK_LINES = {{ csv_options.skip_blank_lines | upper }}
-            {%- endif %}
-            {%- if csv_options.date_format %}
-                DATE_FORMAT = '{{ csv_options.date_format }}'
-            {%- endif %}
-            {%- if csv_options.timestamp_format %}
-                TIMESTAMP_FORMAT = '{{ csv_options.timestamp_format }}'
-            {%- endif %}
-        {%- endif %}
-    {%- endif %}
-    {%- if credentials %}
-    CREDENTIALS = (AWS_KEY_ID = '{{credentials.aws_key_id}}' AWS_SECRET_KEY = '{{credentials.aws_secret_key}}')
-    {%- endif %}
-{% endmacro %}

dbt/include/firebolt/macros/dbt_external_tables/dropif.sql

@@ -1,6 +0,0 @@
-{% macro firebolt__dropif(source_node) %}
-    {% set ddl %}
-        DROP TABLE IF EXISTS {{ source_node['name'] }}
-    {% endset %}
-    {{return(ddl)}}
-{% endmacro %}

dbt/include/firebolt/macros/dbt_external_tables/get_external_build_plan.sql

@@ -1,18 +0,0 @@
-{% macro firebolt__get_external_build_plan(source_node) %}
-    {% set build_plan = [] %}
-    {% set old_relation = adapter.get_relation(
-        database = source_node.database,
-        schema = source_node.schema,
-        identifier = source_node.identifier
-    ) %}
-    {# var(variable, Boolean) defaults to Boolean value if variable isnt set.
-       Firebolt doesn't do refresh because we don't need to—external tables will always
-       pull most recent data from S3, so the default action below is to skip. #}
-    {% if old_relation is none or var('ext_full_refresh', false) %}
-        {% set build_plan = build_plan + [dropif(source_node),
-                                          create_external_table(source_node)] %}
-    {% else %}
-        {% set build_plan = dbt_external_tables.refresh_external_table(source_node) %}
-    {% endif %}
-    {% do return(build_plan) %}
-{% endmacro %}

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

@@ -1,3 +0,0 @@
-{% macro firebolt__can_clone_table() %}
-    {{ return(False) }}
-{% endmacro %}

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

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

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

@@ -1,21 +0,0 @@
-{% macro intersect_columns(source_columns, target_columns) %}
-  {# Return a List[FireboltColumn] of columns that appear in both source and target.
-     Args:
-       source_columns: List[FireboltColumn]
-       target_columns: List[FireboltColumn]
-  #}
-  {% set result = [] %}
-  {# Note I'm using `column` and not `name` below, as name is a getter
-     and column is the actual field. #}
-  {% set source_names = source_columns | map(attribute = 'column') | list %}
-  {% set target_names = target_columns | map(attribute = 'column') | list %}
-  {# Check whether the name attribute exists in the target - this does
-     not perform a data type check. This is O(m•n), but cardinality
-     of columns is probably low enough that it doesn't matter. #}
-  {% for sc in source_columns %}
-    {% if sc.name in target_names %}
-       {{ result.append(sc) }}
-    {% endif %}
-  {% endfor %}
-  {{ return(result) }}
-{% endmacro %}

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 %}